@rialo/ts-cdk 0.1.9 → 0.2.0-alpha.0

package/dist/index.d.ts

@@ -1,140 +1,3 @@
-/**
- * Error handling for the Rialo CDK.
- *
- * This module defines the common error types used throughout the Rialo CDK.
- * It provides a centralized error handling mechanism for all operations.
- */
-/**
- * Structured RPC error information parsed from JSON-RPC error responses.
- */
-interface RpcErrorDetails$1 {
-    /** HTTP status code (e.g., 200, 422, 500) */
-    status?: number;
-    /** JSON-RPC error code (e.g., -32002) */
-    code: number;
-    /** Human-readable error message */
-    message: string;
-}
-/**
- * Error types for different subsystems in the Rialo CDK.
- */
-declare enum RialoErrorType {
-    /** Errors related to file or system I/O operations */
-    IO = "IO",
-    /** Errors occurring during RPC communication with blockchain nodes */
-    RPC = "RPC",
-    /** Errors related to public key parsing or validation */
-    PARSE_PUBKEY = "PARSE_PUBKEY",
-    /** Errors related to blockhash parsing or validation */
-    INVALID_BLOCKHASH_FORMAT = "INVALID_BLOCKHASH_FORMAT",
-    /** Errors related to wallet operations such as creation, loading, or signing */
-    WALLET = "WALLET",
-    /** Errors related to configuration loading, parsing, or validation */
-    CONFIG = "CONFIG",
-    /** Errors occurring during transaction building, signing, or submission */
-    TRANSACTION = "TRANSACTION",
-    /** Network-related errors, including HTTP client errors */
-    NETWORK = "NETWORK",
-    /** Errors related to password handling, validation, or verification */
-    PASSWORD = "PASSWORD",
-    /** Errors related to encryption or decryption operations */
-    ENCRYPTION = "ENCRYPTION",
-    /** Errors occurring during JSON parsing, serialization, or deserialization */
-    JSON = "JSON",
-    /** Errors related to BIP32 key derivation */
-    BIP32 = "BIP32",
-    /** Errors related to invalid input parameters or data */
-    INVALID_INPUT = "INVALID_INPUT",
-    /** Errors related to serialization/deserialization */
-    SERIALIZATION = "SERIALIZATION"
-}
-/**
- * Base error class for all Rialo CDK errors.
- *
- * Provides structured error handling with type categorization and optional
- * cause tracking for error chains. Use the static factory methods for
- * consistent error creation across the SDK.
- *
- * @example
- * ```typescript
- * // Create typed errors using factory methods
- * throw RialoError.invalidInput("Amount must be positive");
- * throw RialoError.network("Connection failed", originalError);
- * throw RialoError.rpc({ code: -32002, message: "Invalid params" });
- *
- * // Handle errors with type information
- * try {
- *   await client.sendTransaction(tx);
- * } catch (error) {
- *   if (error instanceof RialoError && error.type === RialoErrorType.NETWORK) {
- *     console.log("Network error, retrying...");
- *   }
- * }
- * ```
- */
-declare class RialoError extends Error {
-    readonly type: RialoErrorType;
-    readonly cause?: Error;
-    readonly details?: RpcErrorDetails$1;
-    constructor(type: RialoErrorType, message: string, cause?: Error, details?: RpcErrorDetails$1);
-    /**
-     * Creates an IO error.
-     */
-    static io(message: string, cause?: Error): RialoError;
-    /**
-     * Creates an RPC error.
-     */
-    static rpc(details: RpcErrorDetails$1): RialoError;
-    /**
-     * Creates a public key parsing error.
-     */
-    static parsePubkey(message: string): RialoError;
-    /**
-     * Creates a blockhash format error.
-     */
-    static invalidBlockhash(message: string): RialoError;
-    /**
-     * Creates a wallet error.
-     */
-    static wallet(message: string): RialoError;
-    /**
-     * Creates a configuration error.
-     */
-    static config(message: string): RialoError;
-    /**
-     * Creates a transaction error.
-     */
-    static transaction(message: string): RialoError;
-    /**
-     * Creates a network error.
-     */
-    static network(message: string, cause?: Error): RialoError;
-    /**
-     * Creates a password error.
-     */
-    static password(message: string): RialoError;
-    /**
-     * Creates an encryption error.
-     */
-    static encryption(message: string): RialoError;
-    /**
-     * Creates a JSON error.
-     */
-    static json(message: string, cause?: Error): RialoError;
-    /**
-     * Creates a BIP32 error.
-     */
-    static bip32(message: string): RialoError;
-    /**
-     * Creates an invalid input error.
-     */
-    static invalidInput(message: string): RialoError;
-    /**
-     * Creates a serialization error.
-     */
-    static serialization(message: string): RialoError;
-}
-
 interface HttpTransportConfig {
     /** Request timeout in milliseconds */
     timeout?: number;
@@ -228,10 +91,13 @@ declare const URL_TESTNET: string;
 declare const URL_DEVNET: string;
 /** Rialo localnet RPC URL */
 declare const URL_LOCALNET: string;
+/** Rialo shitnet RPC URL */
+declare const URL_SHITNET: 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;
+declare const RIALO_SHITNET_CHAIN: ChainDefinition;
 /** System program ID */
 declare const SYSTEM_PROGRAM_ID: string;
 /** Base derivation path for Rialo wallets (BIP44 coin type 756) */
@@ -252,7 +118,12 @@ declare enum CryptoErrorCode {
     INVALID_BLOCKHASH = "INVALID_BLOCKHASH",
     INVALID_MNEMONIC = "INVALID_MNEMONIC",
     KEY_DERIVATION_FAILED = "KEY_DERIVATION_FAILED",
-    KEYPAIR_DISPOSED = "KEYPAIR_DISPOSED"
+    KEYPAIR_DISPOSED = "KEYPAIR_DISPOSED",
+    MAX_SEED_LENGTH_EXCEEDED = "MAX_SEED_LENGTH_EXCEEDED",
+    MAX_SEEDS_EXCEEDED = "MAX_SEEDS_EXCEEDED",
+    INVALID_SEEDS_ON_CURVE = "INVALID_SEEDS_ON_CURVE",
+    NO_VIABLE_BUMP_SEED = "NO_VIABLE_BUMP_SEED",
+    INVALID_SEED = "INVALID_SEED"
 }
 /**
  * Error class for cryptographic operations.
@@ -316,6 +187,18 @@ declare class Signature {
     toJSON(): string;
 }
 
+/**
+ * A seed for PDA derivation - string (UTF-8) or raw bytes.
+ */
+type Seed = string | Uint8Array;
+/**
+ * Bump seed (0-255) that pushes derived address off the Ed25519 curve.
+ */
+type Bump = number;
+/**
+ * Result of PDA derivation: [address, bump].
+ */
+type PDA = readonly [PublicKey, Bump];
 /**
  * Represents a 32-byte Ed25519 public key.
  *
@@ -350,6 +233,80 @@ declare class PublicKey {
      * @throws {CryptoError} If string is invalid or decodes to wrong length
      */
     static fromString(str: string): PublicKey;
+    /**
+     * Derives a program address from seeds and a program ID.
+     *
+     * @remarks
+     * This is the low-level derivation function. It will throw if the resulting
+     * address falls on the Ed25519 curve. For most use cases, prefer
+     * {@link findProgramAddress} which automatically finds a valid bump seed.
+     *
+     * Use this method when you already know the bump seed (e.g., stored on-chain
+     * or passed from a previous computation) for better performance.
+     *
+     * @param seeds - Array of seeds (strings or byte arrays, max 16 seeds, each max 32 bytes)
+     * @param programId - The program that will own this PDA
+     * @returns The derived public key
+     * @throws {CryptoError} If seeds exceed limits or result is on curve
+     *
+     * @example
+     * ```typescript
+     * // With known bump seed (most efficient for verification)
+     * const pda = PublicKey.createProgramAddress(
+     *   ["metadata", mintPubkey.toBytes(), new Uint8Array([254])],
+     *   metadataProgramId
+     * );
+     * ```
+     */
+    static createProgramAddress(seeds: Seed[], programId: PublicKey): PublicKey;
+    /**
+     * Finds a valid program derived address by searching for a bump seed.
+     *
+     * @remarks
+     * Iterates from bump 255 down to 0, returning the first combination that
+     * produces an address off the Ed25519 curve. The bump seed should be stored
+     * or passed to programs to allow efficient verification via {@link createProgramAddress}.
+     *
+     * @param seeds - Array of seeds (max 16 seeds, each max 32 bytes)
+     * @param programId - The program that will own this PDA
+     * @returns Tuple of [PublicKey, Bump] where bump is 0-255
+     * @throws {CryptoError} If no valid bump found (extremely rare) or seeds invalid
+     *
+     * @example
+     * ```typescript
+     * const [vaultPda, vaultBump] = PublicKey.findProgramAddress(
+     *   ["vault", userPubkey.toBytes()],
+     *   programId
+     * );
+     *
+     * // Store bump for later use
+     * console.log(`Vault: ${vaultPda}, Bump: ${vaultBump}`);
+     * ```
+     */
+    static findProgramAddress(seeds: Seed[], programId: PublicKey): PDA;
+    /**
+     * Creates a derived address from a base address, seed string, and program ID.
+     *
+     * @remarks
+     * Unlike PDAs, this derivation CAN produce addresses on the curve.
+     * This is useful for creating deterministic addresses that a user can sign for,
+     * where the base address's private key holder can sign transactions.
+     *
+     * @param baseAddress - The base public key (signer)
+     * @param seed - A seed string (max 32 bytes when UTF-8 encoded)
+     * @param programId - The program that will own the derived account
+     * @returns The derived address
+     *
+     * @example
+     * ```typescript
+     * const derivedAddress = PublicKey.createWithSeed(
+     *   userPubkey,
+     *   "savings-account",
+     *   systemProgramId
+     * );
+     * ```
+     */
+    static createWithSeed(baseAddress: PublicKey, seed: string, programId: PublicKey): PublicKey;
     /**
      * Returns a copy of the raw bytes.
      */
@@ -377,6 +334,12 @@ declare class PublicKey {
      * ```
      */
     verify(message: Uint8Array, signature: Signature): boolean;
+    /**
+     * Checks if the public key is on the Ed25519 curve.
+     *
+     * @returns True if the public key is on the curve, false otherwise
+     */
+    isOnCurve(): boolean;
     /**
      * JSON serialization (returns base58 string).
      */
@@ -599,1437 +562,1911 @@ declare class Mnemonic {
 }
 
 /**
- * Metadata about an account in a transaction.
- */
-interface AccountMeta {
-    /** Account public key */
-    readonly pubkey: PublicKey;
-    /** Whether this account must sign the transaction */
-    readonly isSigner: boolean;
-    /** Whether this account's data will be modified */
-    readonly isWritable: boolean;
-}
-/**
- * An instruction to execute on-chain.
+ * Checks if a 32-byte array represents a valid point on the Ed25519 curve.
+ *
+ * This is used for PDA (Program Derived Address) derivation, where valid PDAs
+ * must NOT be on the curve to ensure they can only be signed by the program.
+ *
+ * @param bytes - 32-byte public key or hash to check
+ * @returns true if the bytes represent a valid Ed25519 point, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const hash = sha256(data);
+ * if (!isOnCurve(hash)) {
+ *   // Valid PDA - not on curve
+ * }
+ * ```
  */
-interface Instruction {
-    /** Program that will execute this instruction */
-    readonly programId: PublicKey;
-    /** Accounts used by this instruction */
-    readonly accounts: readonly AccountMeta[];
-    /** Instruction-specific data */
-    readonly data: Uint8Array;
-}
+declare function isOnCurve(bytes: Uint8Array): boolean;
 /**
- * Message header containing signature requirements.
+ * Converts a seed to a 32-byte array.
+ *
+ * @param seed - Seed to convert
+ * @returns 32-byte array
  */
-interface MessageHeader {
-    /** Number of signatures required */
-    readonly numRequiredSignatures: number;
-    /** Number of read-only signed accounts */
-    readonly numReadonlySignedAccounts: number;
-    /** Number of read-only unsigned accounts */
-    readonly numReadonlyUnsignedAccounts: number;
-}
+declare function seedToBytes(seed: Seed): Uint8Array;
 /**
- * Compiled instruction with account indices.
+ * Concatenates multiple byte arrays into a single byte array.
+ *
+ * @param arrays - Byte arrays to concatenate
+ * @returns Concatenated byte array
  */
-interface CompiledInstruction {
-    /** Index of program in account keys array */
-    readonly programIdIndex: number;
-    /** Indices of accounts in account keys array */
-    readonly accountKeyIndexes: readonly number[];
-    /** Instruction data */
-    readonly data: Uint8Array;
-}
+declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
 
 /**
- * Account metadata table for deduplication and sorting.
- * Avoids: Complex account sorting logic scattered throughout builder
+ * Error handling for the Rialo CDK.
+ *
+ * This module defines the common error types used throughout the Rialo CDK.
+ * It provides a centralized error handling mechanism for all operations.
  */
-
 /**
- * Internal account entry with aggregated metadata.
+ * Structured RPC error information parsed from JSON-RPC error responses.
  */
-interface AccountEntry {
-    pubkey: PublicKey;
-    isSigner: boolean;
-    isWritable: boolean;
+interface RpcErrorDetails$1 {
+    /** HTTP status code (e.g., 200, 422, 500) */
+    status?: number;
+    /** JSON-RPC error code (e.g., -32002) */
+    code: number;
+    /** Human-readable error message */
+    message: string;
 }
 /**
- * Manages account deduplication and sorting for transaction messages.
- *
- * Accounts are sorted according to these rules:
- * 1. Signer + writable accounts first
- * 2. Then signer + readonly accounts
- * 3. Then non-signer + writable accounts
- * 4. Finally non-signer + readonly accounts
- * 5. Within each group, sort by public key bytes
- *
- * This matches Solana's account sorting rules for compatibility.
+ * Error types for different subsystems in the Rialo CDK.
  */
-declare class AccountMetaTable {
-    private readonly accounts;
-    private readonly accountOrder;
-    /**
-     * Add or update an account in the table.
-     * If account already exists, merges signer/writable flags (OR operation).
+declare enum RialoErrorType {
+    /** Errors related to file or system I/O operations */
+    IO = "IO",
+    /** Errors occurring during RPC communication with blockchain nodes */
+    RPC = "RPC",
+    /** Errors related to public key parsing or validation */
+    PARSE_PUBKEY = "PARSE_PUBKEY",
+    /** Errors related to blockhash parsing or validation */
+    INVALID_BLOCKHASH_FORMAT = "INVALID_BLOCKHASH_FORMAT",
+    /** Errors related to wallet operations such as creation, loading, or signing */
+    WALLET = "WALLET",
+    /** Errors related to configuration loading, parsing, or validation */
+    CONFIG = "CONFIG",
+    /** Errors occurring during transaction building, signing, or submission */
+    TRANSACTION = "TRANSACTION",
+    /** Network-related errors, including HTTP client errors */
+    NETWORK = "NETWORK",
+    /** Errors related to password handling, validation, or verification */
+    PASSWORD = "PASSWORD",
+    /** Errors related to encryption or decryption operations */
+    ENCRYPTION = "ENCRYPTION",
+    /** Errors occurring during JSON parsing, serialization, or deserialization */
+    JSON = "JSON",
+    /** Errors related to BIP32 key derivation */
+    BIP32 = "BIP32",
+    /** Errors related to invalid input parameters or data */
+    INVALID_INPUT = "INVALID_INPUT",
+    /** Errors related to serialization/deserialization */
+    SERIALIZATION = "SERIALIZATION"
+}
+/**
+ * Base error class for all Rialo CDK errors.
+ *
+ * Provides structured error handling with type categorization and optional
+ * cause tracking for error chains. Use the static factory methods for
+ * consistent error creation across the SDK.
+ *
+ * @example
+ * ```typescript
+ * // Create typed errors using factory methods
+ * throw RialoError.invalidInput("Amount must be positive");
+ * throw RialoError.network("Connection failed", originalError);
+ * throw RialoError.rpc({ code: -32002, message: "Invalid params" });
+ *
+ * // Handle errors with type information
+ * try {
+ *   await client.sendTransaction(tx);
+ * } catch (error) {
+ *   if (error instanceof RialoError && error.type === RialoErrorType.NETWORK) {
+ *     console.log("Network error, retrying...");
+ *   }
+ * }
+ * ```
+ */
+declare class RialoError extends Error {
+    readonly type: RialoErrorType;
+    readonly cause?: Error;
+    readonly details?: RpcErrorDetails$1;
+    constructor(type: RialoErrorType, message: string, cause?: Error, details?: RpcErrorDetails$1);
+    /**
+     * Creates an IO error.
      */
-    add(meta: AccountMeta): void;
+    static io(message: string, cause?: Error): RialoError;
     /**
-     * Add multiple accounts at once.
+     * Creates an RPC error.
      */
-    addAll(metas: readonly AccountMeta[]): void;
+    static rpc(details: RpcErrorDetails$1): RialoError;
     /**
-     * Get the index of an account in the sorted order.
-     * Returns -1 if account not found.
+     * Creates a public key parsing error.
      */
-    getIndex(pubkey: PublicKey): number;
+    static parsePubkey(message: string): RialoError;
     /**
-     * Get sorted accounts according to transaction rules.
+     * Creates a blockhash format error.
      */
-    getSortedAccounts(): readonly AccountEntry[];
+    static invalidBlockhash(message: string): RialoError;
     /**
-     * Get the message header based on sorted accounts.
+     * Creates a wallet error.
      */
-    getHeader(): MessageHeader;
+    static wallet(message: string): RialoError;
     /**
-     * Get sorted public keys.
+     * Creates a configuration error.
      */
-    getPublicKeys(): readonly PublicKey[];
+    static config(message: string): RialoError;
     /**
-     * Get number of accounts in table.
+     * Creates a transaction error.
      */
-    size(): number;
+    static transaction(message: string): RialoError;
+    /**
+     * Creates a network error.
+     */
+    static network(message: string, cause?: Error): RialoError;
+    /**
+     * Creates a password error.
+     */
+    static password(message: string): RialoError;
+    /**
+     * Creates an encryption error.
+     */
+    static encryption(message: string): RialoError;
+    /**
+     * Creates a JSON error.
+     */
+    static json(message: string, cause?: Error): RialoError;
+    /**
+     * Creates a BIP32 error.
+     */
+    static bip32(message: string): RialoError;
+    /**
+     * Creates an invalid input error.
+     */
+    static invalidInput(message: string): RialoError;
+    /**
+     * Creates a serialization error.
+     */
+    static serialization(message: string): RialoError;
+}
+
+/**
+ * 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;
+    /** Account data */
+    data: Uint8Array;
+    /** Whether the account is executable */
+    executable: boolean;
+    /** Rent epoch */
+    rentEpoch: bigint;
+}
+/**
+ * Transaction response.
+ */
+interface TransactionResponse {
+    /** Transaction signature */
+    signature: string;
+    /** Block height */
+    blockHeight?: bigint;
+    /** Error message if transaction failed */
+    err?: string;
+}
+/**
+ * Options for sending a transaction.
+ */
+interface SendTransactionOptions {
+    /** Skip preflight transaction checks */
+    skipPreflight?: boolean;
+    /** Maximum number of times to retry */
+    maxRetries?: number;
+}
+/**
+ * Epoch information response.
+ */
+interface EpochInfoResponse {
+    /** Current epoch */
+    epoch: bigint;
+    /** Current slot in the epoch */
+    slotIndex: bigint;
+    /** Total slots in the epoch */
+    slotsInEpoch: bigint;
+    /** Absolute slot number */
+    absoluteSlot: bigint;
+    /** Block height */
+    blockHeight: bigint;
+    /** Transaction count */
+    transactionCount?: bigint;
+}
+/**
+ * Subscription kind.
+ */
+type SubscriptionKind = "Persistent" | "OneShot";
+/**
+ * Subscription data.
+ */
+interface Subscription {
+    /** Type of subscription */
+    kind: SubscriptionKind;
+    /** Topic for the subscription */
+    topic: string;
+    /** Instructions to execute when triggered */
+    instructions: unknown[];
+    /** Subscriber public key (base58) */
+    subscriber: string;
+    /** Event account public key (base58) */
+    eventAccount?: string;
+    /** Timestamp range [start, end] */
+    timestampRange?: [bigint, bigint];
+}
+/**
+ * Triggered transaction data.
+ */
+interface TriggeredTransaction {
+    /** Transaction signature (base58) */
+    signature: string;
+    /** Block number where the transaction was executed */
+    blockNumber: bigint;
+}
+/**
+ * Get workflow lineage request.
+ */
+interface GetWorkflowLineageRequest {
+    /** Root transaction signature (base58) */
+    signature: string;
+    /** Maximum depth to traverse (1-100, default 3) */
+    maxDepth?: number;
+    /** Whether to include event details */
+    includeEvents?: boolean;
+}
+/**
+ * Event data from a workflow trigger.
+ */
+interface EventData {
+    /** Event topic */
+    topic: string;
+    /** Event attributes */
+    attributes: Record<string, unknown>;
+}
+/**
+ * Timestamp range.
+ */
+interface TimestampRange {
+    /** Start timestamp (unix) */
+    from: bigint;
+    /** End timestamp (unix) */
+    to: bigint;
+}
+/**
+ * Information about what triggered a workflow transaction.
+ */
+interface TriggerInfo {
+    /** Event that triggered the transaction */
+    event: EventData;
+    /** Subscription public key (base58) */
+    subscriptionPubkey: string;
+    /** Timestamp range for the trigger */
+    timestampRange?: TimestampRange;
+    /** Event account public key (base58) */
+    eventAccount?: string;
+}
+/**
+ * Transaction node data within a workflow.
+ */
+interface TransactionNodeData {
+    /** Block height */
+    blockHeight: bigint;
+    /** Timestamp (unix) */
+    timestamp: bigint;
+    /** Whether the transaction succeeded */
+    success: boolean;
+    /** Number of instructions */
+    instructionCount: number;
+    /** Program IDs of instructions (base58) */
+    instructionProgramIds: string[];
+}
+/**
+ * A node in the workflow lineage tree.
+ */
+interface WorkflowNode {
+    /** Transaction signature (base58) */
+    id: string;
+    /** Distance from root transaction */
+    depth: number;
+    /** Transaction data */
+    data: TransactionNodeData;
+    /** Subscriptions on this transaction */
+    subscriptions: Subscription[];
+    /** What triggered this transaction */
+    triggeredBy?: TriggerInfo;
+    /** Child transaction signatures (base58) */
+    workflowChildren: string[];
+    /** Whether there are more children not shown */
+    hasMoreChildren: boolean;
+}
+/**
+ * Workflow lineage tree.
+ */
+interface WorkflowLineage {
+    /** Nodes in the workflow tree */
+    workflowNodes: WorkflowNode[];
+}
+/**
+ * Reason for truncating workflow lineage traversal.
+ */
+type TruncationReason = "MaxDepth" | "MaxNodes" | "None";
+/**
+ * Get workflow lineage response.
+ */
+interface GetWorkflowLineageResponse {
+    /** Workflow lineage tree */
+    lineage: WorkflowLineage;
+    /** Leaf transaction signatures (base58) */
+    leaves: string[];
+    /** Whether traversal was truncated */
+    truncated: boolean;
+    /** Reason for truncation */
+    truncationReason: TruncationReason;
+    /** Hints for continuing traversal (base58 signatures) */
+    continuationHints: string[];
+}
+/**
+ * Get signatures for address configuration.
+ */
+interface GetSignaturesForAddressConfig {
+    /** Maximum number of signatures to return */
+    limit?: number;
+    /** Start searching backwards from this signature */
+    before?: string;
+    /** Start searching forwards from this signature */
+    until?: string;
+}
+/**
+ * Signature information.
+ */
+interface SignatureInfo {
+    signature: string;
+    blockHeight: bigint;
+    blockTime: bigint;
+    err?: string;
+}
+/**
+ * Get health response.
+ */
+type GetHealthResponse = "ok" | string;
+/**
+ * Get transactions configuration.
+ */
+interface GetTransactionsConfig {
+    /** Maximum number of transactions to return */
+    limit?: number;
+    /** Encoding format */
+    encoding?: "json" | "base58" | "base64";
 }
-
 /**
- * Error codes for transaction operations.
+ * Get transactions response.
  */
-declare enum TransactionErrorCode {
-    INVALID_INSTRUCTION = "INVALID_INSTRUCTION",
-    INVALID_ACCOUNT_META = "INVALID_ACCOUNT_META",
-    NO_INSTRUCTIONS = "NO_INSTRUCTIONS",
-    DUPLICATE_ACCOUNT = "DUPLICATE_ACCOUNT",
-    MISSING_SIGNATURE = "MISSING_SIGNATURE",
-    INVALID_SIGNATURE = "INVALID_SIGNATURE",
-    SIGNATURE_OUT_OF_BOUNDS = "SIGNATURE_OUT_OF_BOUNDS",
-    SIGNER_NOT_FOUND = "SIGNER_NOT_FOUND",
-    ALREADY_SIGNED = "ALREADY_SIGNED",
-    INVALID_MESSAGE_FORMAT = "INVALID_MESSAGE_FORMAT",
-    INSUFFICIENT_DATA = "INSUFFICIENT_DATA",
-    SERIALIZATION_FAILED = "SERIALIZATION_FAILED",
-    SIMULATION_FAILED = "SIMULATION_FAILED",
-    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
-    BLOCKHASH_EXPIRED = "BLOCKHASH_EXPIRED"
+interface GetTransactionsResponse {
+    /** Array of transaction data */
+    transactions: Array<Record<string, unknown>>;
 }
 /**
- * Error class for transaction operations with structured error information.
+ * Signature status from the RPC.
  */
-declare class TransactionError extends Error {
-    readonly code: TransactionErrorCode;
-    readonly details?: Record<string, unknown> | undefined;
-    constructor(code: TransactionErrorCode, message: string, details?: Record<string, unknown> | undefined);
-    static noInstructions(): TransactionError;
-    static signerNotFound(pubkey: string): TransactionError;
-    static missingSignature(index: number, pubkey: string): TransactionError;
-    static simulationFailed(logs: string[], error: string): TransactionError;
-    static insufficientFunds(required: bigint, available: bigint): TransactionError;
-    toJSON(): {
-        code: TransactionErrorCode;
-        message: string;
-        details?: Record<string, unknown>;
-    };
+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;
 }
-
 /**
- * Create an instruction with Borsh-encoded data.
- *
- * @example
- * ```typescript
- * // Define your instruction data class
- * class MyInstructionData {
- *   @field({ type: 'u8' })
- *   instruction: number;
- *
- *   @field({ type: 'u64' })
- *   amount: bigint;
- *
- *   @field({ type: option('string') })
- *   memo?: string;
- * }
- *
- * // Create instruction
- * const instruction = createBorshInstruction({
- *   programId: myProgramId,
- *   accounts: [
- *     { pubkey: account1, isSigner: true, isWritable: true },
- *     { pubkey: account2, isSigner: false, isWritable: false },
- *   ],
- *   data: new MyInstructionData({
- *     instruction: 5,
- *     amount: 1000n,
- *     memo: "Hello, Rialo!",
- *   }),
- * });
- * ```
+ * Options for confirming a transaction.
  */
-declare function createBorshInstruction<T>(params: {
-    programId: PublicKey;
-    accounts: AccountMeta[];
-    data: T;
-}): Instruction;
+interface ConfirmTransactionOptions {
+    /** Maximum number of retry attempts (default: 30) */
+    maxRetries?: number;
+    /** Delay between retries in milliseconds (default: 1000) */
+    retryDelay?: number;
+}
 /**
- * Helper for creating Borsh-serialized instruction data from a plain object.
- *
- * This is useful when you don't want to define a class with decorators.
- *
- * @example
- * ```typescript
- * const data = encodeBorshData({
- *   instruction: { type: 'u8', value: 1 },
- *   amount: { type: 'u64', value: 1000n },
- *   recipient: { type: fixedArray('u8', 32), value: recipientBytes },
- * });
- * ```
+ * Options for sending and confirming a transaction.
  */
-declare function encodeBorshData(_schema: Record<string, {
-    type: unknown;
-    value: unknown;
-}>): Uint8Array;
-
+interface SendAndConfirmOptions extends SendTransactionOptions, ConfirmTransactionOptions {
+}
 /**
- * System program instruction types.
+ * Result of a confirmed transaction.
  */
-declare enum SystemInstruction {
-    CreateAccount = 0,
-    Assign = 1,
-    Transfer = 2,
-    CreateAccountWithSeed = 3,
-    AdvanceNonceAccount = 4,
-    WithdrawNonceAccount = 5,
-    InitializeNonceAccount = 6,
-    AuthorizeNonceAccount = 7,
-    Allocate = 8,
-    AllocateWithSeed = 9,
-    AssignWithSeed = 10,
-    TransferWithSeed = 11
+interface ConfirmedTransaction {
+    /** Transaction signature */
+    signature: string;
+    /** Whether the transaction was executed */
+    executed: boolean;
+    /** Error message if transaction failed */
+    err?: string;
 }
 /**
- * Create a transfer instruction.
- *
- * Transfers native tokens from one account to another.
- *
- * @param from - Source account (must be signer)
- * @param to - Destination account
- * @param amount - Amount to transfer in smallest denomination (lamports)
- *
- * @example
- * ```typescript
- * const instruction = transferInstruction(fromPubkey, toPubkey, 1_000_000n);
- *
- * const tx = TransactionBuilder.create()
- *   .setPayer(fromPubkey)
- *   .addInstruction(instruction)
- *   .build();
- * ```
+ * Configuration for getAccountsByOwner.
  */
-declare function transferInstruction(from: PublicKey, to: PublicKey, amount: bigint): Instruction;
+interface GetAccountsByOwnerConfig {
+    /** Encoding format for account data */
+    encoding?: "base64" | "base58" | "json" | "jsonParsed";
+    /** Maximum number of accounts to return */
+    limit?: number;
+    /** Cursor for pagination (base58 pubkey) */
+    after?: string;
+}
 /**
- * Create an account creation instruction.
- *
- * @param from - Funding account (must be signer)
- * @param newAccount - New account to create (must be signer)
- * @param lamports - Initial balance for new account
- * @param space - Number of bytes to allocate for account data
- * @param owner - Program that will own the new account
+ * Filter for getAccountsByOwner.
+ * Matches Rust serde serialization format.
+ */
+type AccountFilter = {
+    type: "programAccounts";
+} | {
+    type: "tokenAccounts";
+    mint?: string;
+};
+/**
+ * An account owned by a program or address.
  */
-declare function createAccount(from: PublicKey, newAccount: PublicKey, lamports: bigint, space: bigint, owner: PublicKey): Instruction;
+interface OwnerAccount {
+    /** Account public key */
+    pubkey: PublicKey;
+    /** Account information */
+    account: AccountInfo;
+}
+/**
+ * Pagination information.
+ */
+interface PaginationInfo {
+    /** Whether there are more results */
+    hasMore: boolean;
+    /** Cursor for next page (base58 pubkey) */
+    nextCursor?: string;
+}
+/**
+ * Get accounts by owner response.
+ */
+interface GetAccountsByOwnerResponse {
+    /** Array of owned accounts */
+    value: OwnerAccount[];
+    /** Pagination information */
+    pagination?: PaginationInfo;
+}
 
 /**
- * An unsigned transaction message ready to be signed.
+ * Main Rialo RPC client for blockchain interactions.
+ */
+
+/**
+ * High-level Rialo RPC client for blockchain interactions.
  *
- * This is the data that gets signed by transaction signers.
- * It's immutable to prevent accidental modification after creation.
+ * Provides a unified interface for querying blockchain state and
+ * sending transactions. Internally delegates to specialized clients
+ * (QueryRpcClient, TransactionRpcClient) for modular organization.
  *
  * @example
  * ```typescript
- * const message = MessageBuilder.create()
- *   .setPayer(payer)
- *   .setValidFrom(validFrom)
- *   .addInstruction(transferInstruction)
- *   .build();
+ * import { createRialoClient, RIALO_DEVNET_CHAIN } from '@rialo/ts-cdk';
  *
- * // Serialize for signing
- * const messageBytes = message.serialize();
+ * const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });
+ *
+ * // Query operations
+ * const balance = await client.getBalance(publicKey);
+ * const chainId = client.getChainIdentifier();
+ *
+ * // Transaction operations
+ * const signature = await client.sendTransaction(signedTx);
  * ```
  */
-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[]);
+declare class RialoClient {
+    private readonly queryClient;
+    private readonly transactionClient;
+    private readonly transport;
+    private readonly chain;
+    constructor(transport: HttpTransport, chain: ChainDefinition);
+    /**
+     * Returns the configured RPC endpoint URL.
+     */
+    getUrl(): string;
+    /**
+     * 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.
+     *
+     * @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 the signatures for an address.
+     */
+    getSignaturesForAddress(address: PublicKey, config?: GetSignaturesForAddressConfig): Promise<SignatureInfo[]>;
+    /**
+     * 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)[]>;
     /**
-     * Serialize message to bytes for signing.
-     * Result is cached for performance.
+     * Retrieves current epoch information.
      */
-    serialize(): Uint8Array;
+    getEpochInfo(): Promise<EpochInfoResponse>;
     /**
-     * Deserialize a message from wire format.
+     * Checks the health status of the RPC node.
      *
-     * @param data - Serialized message bytes
-     * @returns Deserialized Message
+     * @returns "ok" if healthy, error message otherwise
      */
-    static deserialize(data: Uint8Array): Message;
-    private serializeInternal;
-    private serializeCompactArray;
-    private serializeCompactU16;
+    getHealth(): Promise<"ok" | string>;
     /**
-     * Get all signers required for this message.
+     * Submits a signed transaction to the blockchain.
+     *
+     * @param transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission options
+     * @returns Transaction signature
      */
-    getSigners(): readonly PublicKey[];
+    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
     /**
-     * Check if a public key is a required signer.
+     * 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
      */
-    isSignerRequired(pubkey: PublicKey): boolean;
+    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
     /**
-     * Get the index of a signer in the signers array.
-     * Returns -1 if not a signer.
+     * 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}`);
+     * ```
      */
-    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 {
+    sendAndConfirmTransaction(transaction: Uint8Array, options?: SendAndConfirmOptions): Promise<ConfirmedTransaction>;
     /**
-     * Retrieves the signer's public key.
+     * Waits for a transaction to be confirmed.
      *
-     * **Note**: May trigger wallet connection prompts for browser wallets.
+     * @param signature - Transaction signature to monitor
+     * @param options - Confirmation options
+     * @returns Confirmed transaction details
      */
-    getPublicKey(): Promise<PublicKey>;
+    confirmTransaction(signature: string, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
     /**
-     * Signs arbitrary message bytes.
+     * Requests an airdrop and waits for confirmation.
      *
-     * @param message - Message bytes to sign
-     * @returns Ed25519 signature over the message
+     * **Note**: Only available on devnet and testnet.
      */
-    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);
+    requestAirdropAndConfirm(pubkey: PublicKey, amount: bigint, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
     /**
-     * Returns the keypair's public key.
+     * Calculate the minimum balance required for an account to be rent-exempt.
+     *
+     * @param accountDataSize - The size of the account data in bytes
+     * @returns The minimum balance in kelvins required for rent exemption
      */
-    getPublicKey(): Promise<PublicKey>;
+    getMinimumBalanceForRentExemption(accountDataSize: number): Promise<bigint>;
     /**
-     * Signs a message using the keypair's private key.
+     * Get the fee required to process a specific message.
+     *
+     * @param message - Base64-encoded serialized versioned message
+     * @returns Fee in kelvins, or null if message is invalid
      */
-    signMessage(message: Uint8Array): Promise<Signature>;
+    getFeeForMessage(message: string): Promise<bigint | null>;
+    /**
+     * Get information for multiple accounts in a single request.
+     *
+     * @param pubkeys - Array of public keys to query (1-100)
+     * @returns Account information for each address
+     */
+    getMultipleAccounts(pubkeys: PublicKey[]): Promise<Array<AccountInfo | null>>;
+    /**
+     * Get all accounts owned by a specific program or address.
+     *
+     * @param owner - Program ID or owner public key
+     * @param filter - Filter type (ProgramAccounts or TokenAccounts)
+     * @param config - Optional configuration for pagination and encoding
+     * @returns Accounts owned by the specified owner
+     */
+    getAccountsByOwner(owner: PublicKey, filter?: AccountFilter, config?: GetAccountsByOwnerConfig): Promise<GetAccountsByOwnerResponse>;
+    /**
+     * Get workflow lineage information for tracking execution history.
+     *
+     * @param request - Workflow lineage request with signature and options
+     * @returns Workflow lineage tree with nodes and metadata
+     */
+    getWorkflowLineage(request: GetWorkflowLineageRequest): Promise<GetWorkflowLineageResponse>;
+    /**
+     * Get subscription for a given subscriber address and nonce.
+     *
+     * @param subscriber - The subscriber's public key
+     * @param nonce - The nonce identifying the subscription
+     * @returns The subscription for the subscriber and nonce
+     */
+    getSubscription(subscriber: PublicKey, nonce: string): Promise<Subscription>;
+    /**
+     * Get transactions triggered by a subscription account.
+     *
+     * @param subscriptionAccount - The subscription account public key
+     * @param limit - Optional limit on transactions returned
+     * @returns Triggered transactions for the subscription
+     */
+    getTriggeredTransactions(subscriptionAccount: PublicKey, limit?: number): Promise<TriggeredTransaction[]>;
 }
 
 /**
- * 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
+     * @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 fromMessage(message: Message): Transaction;
+    getBalance(pubkey: PublicKey): Promise<bigint>;
     /**
-     * Create transaction from message and existing signatures.
-     * @internal
+     * 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 fromMessageAndSignatures(message: Message, signatures: readonly Uint8Array[]): Transaction;
+    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
     /**
-     * Deserialize a transaction from wire format.
+     * 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.
+     *
+     * @returns The current block height
+     *
+     * @example
+     * ```typescript
+     * const height = await client.getBlockHeight();
+     * console.log(`Current block height: ${height}`);
+     * ```
+     */
+    getBlockHeight(): Promise<bigint>;
+    /**
+     * Retrieve transaction signatures for a given address.
+     *
+     * Returns transaction signatures with metadata associated with the specified
+     * address, ordered by slot height (most recent first).
+     *
+     * @param address - The public key of the address to query
+     * @param config - Optional configuration options for the query (limit, before, until)
+     * @returns Response containing context and array of signature info with blockHeight and blockTime
+     *
+     * @example
+     * ```typescript
+     * const result = await client.getSignaturesForAddress(publicKey, { limit: 10 });
+     * console.log(`Query slot: ${result.context.slot}`);
+     * result.value.forEach(sig => {
+     *   console.log(`Transaction: ${sig.signature}, block: ${sig.blockHeight}`);
+     * });
+     * ```
+     */
+    getSignaturesForAddress(address: PublicKey, config?: GetSignaturesForAddressConfig): Promise<SignatureInfo[]>;
+    /**
+     * 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 tx = await client.getTransaction(signature);
+     * if (tx) {
+     *   console.log(`Confirmed in block: ${tx.blockHeight}`);
+     *   if (tx.err) {
+     *     console.log(`Transaction failed: ${tx.err}`);
+     *   }
+     * }
+     * ```
      */
-    static deserialize(data: Uint8Array): Transaction;
-    getMessage(): Message;
+    getTransaction(signature: string): Promise<TransactionResponse | null>;
     /**
-     * Sign the transaction with a keypair.
-     * Returns a NEW Transaction instance.
+     * Retrieve the total number of transactions processed since genesis.
      *
-     * @param keypair - Keypair to sign with
-     * @returns New Transaction instance with signature added
+     * @returns The total transaction count
      *
      * @example
      * ```typescript
-     * const signedTx = tx.sign(keypair);
-     * await client.sendTransaction(signedTx.serialize());
+     * const count = await client.getTransactionCount();
+     * console.log(`Total transactions: ${count}`);
      * ```
      */
-    sign(keypair: Keypair): Transaction;
+    getTransactionCount(): Promise<bigint>;
     /**
-     * Sign with multiple keypairs at once.
-     * 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 signed = tx.signAll([keypair1, keypair2, keypair3]);
+     * 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`);
+     *   }
+     * });
      * ```
      */
-    signAll(keypairs: Keypair[]): Transaction;
+    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
     /**
-     * Sign the transaction with a Signer interface (async).
-     * Returns a NEW Transaction instance.
+     * Retrieve information about the current epoch.
+     *
+     * Returns epoch metadata including the current epoch number, slot position
+     * within the epoch, total slots per epoch, and current block height.
+     *
+     * @returns Current epoch information
      *
      * @example
      * ```typescript
-     * const signedTx = await tx.signWith(browserWallet);
+     * const info = await client.getEpochInfo();
+     * console.log(`Epoch: ${info.epoch}`);
+     * console.log(`Slot ${info.slotIndex} of ${info.slotsInEpoch}`);
+     * console.log(`Block height: ${info.blockHeight}`);
      * ```
      */
-    signWith(signer: Signer): Promise<Transaction>;
+    getEpochInfo(): Promise<EpochInfoResponse>;
     /**
-     * Sign with multiple signers.
-     * Returns a NEW Transaction instance.
+     * Check the health status of the RPC node.
+     *
+     * 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
+     * const health = await client.getHealth();
+     * if (health === "ok") {
+     *   console.log("Node is healthy");
+     * } else {
+     *   console.log(`Node unhealthy: ${health}`);
+     * }
+     * ```
      */
-    signAllWith(signers: Signer[]): Promise<Transaction>;
+    getHealth(): Promise<"ok" | string>;
     /**
-     * Partially sign the transaction (for multi-sig transactions).
-     * Returns a NEW Transaction instance.
+     * Calculate the minimum balance required for an account to be rent-exempt.
+     *
+     * Accounts with at least this balance are exempt from paying rent.
+     *
+     * @param accountDataSize - The size of the account data in bytes
+     * @returns The minimum balance in kelvins required for rent exemption
      *
      * @example
      * ```typescript
-     * const signedTx = tx
-     *   .partialSign(signer1)
-     *   .partialSign(signer2);
+     * const minBalance = await client.getMinimumBalanceForRentExemption(128);
+     * console.log(`Need at least ${minBalance} kelvins for 128 bytes`);
      * ```
      */
-    partialSign(keypair: Keypair): Transaction;
+    getMinimumBalanceForRentExemption(accountDataSize: number): Promise<bigint>;
     /**
-     * Partially sign with a Signer interface (async).
-     * Returns a NEW Transaction instance.
+     * Get the fee required to process a specific message.
+     *
+     * @param message - Base64-encoded serialized versioned message
+     * @returns Fee in kelvins, or null if message is invalid
+     *
+     * @example
+     * ```typescript
+     * const fee = await client.getFeeForMessage(base64Message);
+     * if (fee !== null) {
+     *   console.log(`Fee: ${fee} kelvins`);
+     * }
+     * ```
      */
-    partialSignWith(signer: Signer): Promise<Transaction>;
+    getFeeForMessage(message: string): Promise<bigint | null>;
     /**
-     * Add a signature at a specific index.
-     * Returns a NEW Transaction instance.
+     * Get information for multiple accounts in a single request.
      *
-     * Most users should use sign() or signAll() instead.
+     * Useful for batch operations and reducing RPC calls.
+     *
+     * @param pubkeys - Array of public keys to query (1-100)
+     * @returns Account information for each address (null for non-existent accounts)
+     *
+     * @example
+     * ```typescript
+     * const accounts = await client.getMultipleAccounts([pubkey1, pubkey2]);
+     * accounts.value.forEach((account, i) => {
+     *   if (account) {
+     *     console.log(`Account ${i}: ${account.balance} kelvins`);
+     *   }
+     * });
+     * ```
      */
-    addSignature(index: number, signature: Signature | Uint8Array): Transaction;
+    getMultipleAccounts(pubkeys: PublicKey[]): Promise<Array<AccountInfo | null>>;
     /**
-     * Add a signature for a specific public key.
-     * Returns a NEW Transaction instance.
+     * Get all accounts owned by a specific program or address.
      *
-     * Most users should use sign() or signAll() instead.
+     * Essential for querying token accounts, program data, and more.
+     *
+     * @param owner - Program ID or owner public key
+     * @param filter - Filter type (ProgramAccounts or TokenAccounts)
+     * @param config - Optional configuration for pagination and encoding
+     * @returns Accounts owned by the specified owner with pagination info
+     *
+     * @example
+     * ```typescript
+     * const result = await client.getAccountsByOwner(programId);
+     * console.log(`Found ${result.value.length} accounts`);
+     * result.value.forEach(({ pubkey, account }) => {
+     *   console.log(`${pubkey}: ${account.balance} kelvins`);
+     * });
+     * ```
      */
-    addSignatureForPubkey(pubkey: PublicKey, signature: Signature | Uint8Array): Transaction;
+    getAccountsByOwner(owner: PublicKey, filter?: AccountFilter, config?: GetAccountsByOwnerConfig): Promise<GetAccountsByOwnerResponse>;
     /**
-     * Check if transaction is fully signed (all signatures present).
+     * Get workflow lineage information for tracking execution history.
+     *
+     * Returns the tree of transactions spawned from a root transaction
+     * through subscriptions and triggers.
+     *
+     * @param request - Workflow lineage request with signature and options
+     * @returns Workflow lineage tree with nodes and metadata
+     *
+     * @example
+     * ```typescript
+     * const lineage = await client.getWorkflowLineage({
+     *   signature: rootTxSignature,
+     *   maxDepth: 5,
+     * });
+     * console.log(`Found ${lineage.lineage.workflowNodes.length} nodes`);
+     * ```
      */
-    isSigned(): boolean;
+    getWorkflowLineage(request: GetWorkflowLineageRequest): Promise<GetWorkflowLineageResponse>;
     /**
-     * Check if a specific signature slot is filled.
+     * Get subscriptions for a given subscriber address.
+     *
+     * Returns subscriptions that will trigger transactions when matching events occur.
+     *
+     * @param subscriber - The subscriber's public key
+     * @param nonce - The nonce identifying the subscription
+     * @returns The subscription for the subscriber and nonce
+     *
+     * @example
+     * ```typescript
+     * const subscription = await client.getSubscription(subscriberPubkey, "my-nonce");
+     * console.log(`Topic: ${subscription.topic}, Kind: ${subscription.kind}`);
+     * ```
      */
-    isSignaturePresent(index: number): boolean;
+    getSubscription(subscriber: PublicKey, nonce: string): Promise<Subscription>;
     /**
-     * Get all signatures (returns copies to prevent mutation).
+     * Get transactions triggered by a subscription account.
+     *
+     * Returns the history of transactions that were automatically executed
+     * in response to subscription matches.
+     *
+     * @param subscriptionAccount - The subscription account public key
+     * @param limit - Optional limit on transactions returned
+     * @returns Triggered transactions for the subscription
+     *
+     * @example
+     * ```typescript
+     * const result = await client.getTriggeredTransactions(subscriptionPubkey, 10);
+     * result.transactions.forEach(tx => {
+     *   console.log(`Signature: ${tx.signature}, Block: ${tx.blockNumber}`);
+     * });
+     * ```
      */
-    getSignatures(): readonly Uint8Array[];
+    getTriggeredTransactions(subscriptionAccount: PublicKey, limit?: number): Promise<TriggeredTransaction[]>;
+}
+
+/**
+ * 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 {
     /**
-     * Get a specific signature (returns copy).
+     * Submit a signed transaction to the blockchain.
+     *
+     * 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 transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission options
+     * @returns Transaction signature (base58 encoded)
+     *
+     * @example
+     * ```typescript
+     * const signature = await client.sendTransaction(signedTx);
+     * console.log(`Submitted: ${signature}`);
+     *
+     * // With options
+     * const signature = await client.sendTransaction(signedTx, {
+     *   skipPreflight: true,
+     *   maxRetries: 3,
+     * });
+     * ```
      */
-    getSignature(index: number): Uint8Array;
+    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
     /**
-     * Get a specific signature for a public key.
+     * Wait for a transaction to be confirmed.
+     *
+     * A transaction is considered confirmed when:
+     * - It has been processed in a block (`blockHeight > 0`)
+     *
+     * @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
      */
-    getSignatureForPubkey(pubkey: PublicKey): Uint8Array;
+    confirmTransaction(signature: string, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
     /**
-     * Get required signers for this transaction.
+     * Submit a signed transaction and wait for confirmation.
+     *
+     * 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,
+     * });
+     * ```
      */
-    getSigners(): readonly PublicKey[];
+    sendAndConfirmTransaction(transaction: Uint8Array, options?: SendAndConfirmOptions): Promise<ConfirmedTransaction>;
     /**
-     * Get the number of required signatures.
+     * Request an airdrop of tokens to an account.
+     *
+     * **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}`);
+     * ```
      */
-    getRequiredSignatureCount(): number;
+    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
     /**
-     * Throw an error if the transaction is not fully signed.
+     * Request an airdrop of tokens and wait for confirmation.
      *
-     * @throws {TransactionError} If transaction is not fully signed
+     * **Note**: Only available on devnet and testnet networks.
+     *
+     * 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
-     * signedTx.ensureSigned(); // Throws if not signed
-     * await client.sendTransaction(signedTx.serialize());
+     * const result = await client.requestAirdropAndConfirm(publicKey, 1_000_000_000n);
+     * if (result.executed) {
+     *   console.log("Airdrop confirmed!");
+     * }
      * ```
      */
-    ensureSigned(): void;
+    requestAirdropAndConfirm(pubkey: PublicKey, amount: bigint, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
+    private getTransaction;
     /**
-     * Serialize transaction to wire format.
+     * 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.
      */
-    serialize(): Uint8Array;
+    private sleep;
 }
 
 /**
- * Fluent API for building transactions.
- * Returns Transaction directly (not Message).
+ * 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;
+    };
+}
 
 /**
- * Builder for creating transactions with a fluent API.
+ * Creates an RPC client with automatic retry and timeout handling.
  *
- * Provides an intuitive interface for constructing transactions.
- * Call build() to get an unsigned Transaction ready for signing.
+ * @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
- * // Simple transfer
- * const tx = TransactionBuilder.create()
- *   .setPayer(payer)
- *   .setValidFrom(validFrom)
- *   .addInstruction(transfer(from, to, 1_000_000n))
- *   .build();
+ * // Basic usage with preset chain
+ * const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });
  *
- * const signedTx = tx.sign(keypair);
- * await client.transaction.sendTransaction(signedTx.serialize());
+ * // 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
- * // 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();
+ * // 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 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;
+declare function getDefaultRialoClientConfig(network: RialoNetwork): RialoClientConfig;
+
+/**
+ * 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 {
     /**
-     * Add multiple instructions at once.
+     * Retrieves the signer's public key.
      *
-     * @param instructions - Array of instructions to add
+     * **Note**: May trigger wallet connection prompts for browser wallets.
      */
-    addInstructions(instructions: readonly Instruction[]): this;
+    getPublicKey(): Promise<PublicKey>;
     /**
-     * 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
+     * Signs arbitrary message bytes.
      *
-     * @example
-     * ```typescript
-     * const tx = builder.build();
-     * const signedTx = tx.sign(keypair);
-     * ```
+     * @param message - Message bytes to sign
+     * @returns Ed25519 signature over the message
      */
-    build(): Transaction;
+    signMessage(message: Uint8Array): Promise<Signature>;
 }
 
 /**
- * Base client with JSON-RPC protocol handling.
+ * Signer implementation using a local Ed25519 keypair.
  *
- * 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;
+ * 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);
     /**
-     * Generates the next request ID with Overflow Protection.
-     * @returns The next request ID.
+     * Returns the keypair's public key.
      */
-    private nextRequestId;
+    getPublicKey(): Promise<PublicKey>;
     /**
-     * Returns the configured RPC endpoint URL.
+     * Signs a message using the keypair's private key.
      */
-    getUrl(): string;
+    signMessage(message: Uint8Array): Promise<Signature>;
 }
 
 /**
- * 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;
-    /** Account data */
-    data: Uint8Array;
-    /** Whether the account is executable */
-    executable: boolean;
-    /** Rent epoch */
-    rentEpoch: bigint;
-}
-/**
- * Transaction response.
- */
-interface TransactionResponse {
-    /** Transaction signature */
-    signature: string;
-    /** Block height */
-    blockHeight?: bigint;
-    /** Error message if transaction failed */
-    err?: string;
-}
-/**
- * Options for sending a transaction.
- */
-interface SendTransactionOptions {
-    /** Skip preflight transaction checks */
-    skipPreflight?: boolean;
-    /** Maximum number of times to retry */
-    maxRetries?: number;
-}
-/**
- * Epoch information response.
+ * Metadata about an account in a transaction.
  */
-interface EpochInfoResponse {
-    /** Current epoch */
-    epoch: bigint;
-    /** Current slot in the epoch */
-    slotIndex: bigint;
-    /** Total slots in the epoch */
-    slotsInEpoch: bigint;
-    /** Absolute slot number */
-    absoluteSlot: bigint;
-    /** Block height */
-    blockHeight: bigint;
-    /** Transaction count */
-    transactionCount?: bigint;
+interface AccountMeta {
+    /** Account public key */
+    readonly pubkey: PublicKey;
+    /** Whether this account must sign the transaction */
+    readonly isSigner: boolean;
+    /** Whether this account's data will be modified */
+    readonly isWritable: boolean;
 }
 /**
- * Fee for message response.
+ * An instruction to execute on-chain.
  */
-interface GetFeeForMessageResponse {
-    /** Fee in smallest denomination */
-    value: bigint;
+interface Instruction {
+    /** Program that will execute this instruction */
+    readonly programId: PublicKey;
+    /** Accounts used by this instruction */
+    readonly accounts: readonly AccountMeta[];
+    /** Instruction-specific data */
+    readonly data: Uint8Array;
 }
 /**
- * Multiple accounts response.
+ * Message header containing signature requirements.
  */
-interface MultipleAccountsResponse {
-    /** Array of account information */
-    value: Array<AccountInfo | null>;
+interface MessageHeader {
+    /** Number of signatures required */
+    readonly numRequiredSignatures: number;
+    /** Number of read-only signed accounts */
+    readonly numReadonlySignedAccounts: number;
+    /** Number of read-only unsigned accounts */
+    readonly numReadonlyUnsignedAccounts: number;
 }
 /**
- * Get subscriptions response.
+ * Compiled instruction with account indices.
  */
-interface GetSubscriptionsResponse {
-    /** Array of subscription data */
-    subscriptions: Array<Record<string, unknown>>;
+interface CompiledInstruction {
+    /** Index of program in account keys array */
+    readonly programIdIndex: number;
+    /** Indices of accounts in account keys array */
+    readonly accountKeyIndexes: readonly number[];
+    /** Instruction data */
+    readonly data: Uint8Array;
 }
+
 /**
- * Get triggered transactions response.
+ * Account metadata table for deduplication and sorting.
+ * Avoids: Complex account sorting logic scattered throughout builder
  */
-interface GetTriggeredTransactionsResponse {
-    /** Array of triggered transaction data */
-    transactions: Array<Record<string, unknown>>;
-}
+
 /**
- * Get workflow lineage request.
+ * Internal account entry with aggregated metadata.
  */
-interface GetWorkflowLineageRequest {
-    /** Workflow account public key */
-    workflowAccount: PublicKey;
-    /** Optional limit on results */
-    limit?: number;
+interface AccountEntry {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
 }
 /**
- * Get workflow lineage response.
+ * Manages account deduplication and sorting for transaction messages.
+ *
+ * Accounts are sorted according to these rules:
+ * 1. Signer + writable accounts first
+ * 2. Then signer + readonly accounts
+ * 3. Then non-signer + writable accounts
+ * 4. Finally non-signer + readonly accounts
+ * 5. Within each group, sort by public key bytes
+ *
+ * This matches Solana's account sorting rules for compatibility.
  */
-interface GetWorkflowLineageResponse {
-    /** Workflow lineage data */
-    lineage: Array<Record<string, unknown>>;
+declare class AccountMetaTable {
+    private readonly accounts;
+    private readonly accountOrder;
+    /**
+     * Add or update an account in the table.
+     * If account already exists, merges signer/writable flags (OR operation).
+     */
+    add(meta: AccountMeta): void;
+    /**
+     * Add multiple accounts at once.
+     */
+    addAll(metas: readonly AccountMeta[]): void;
+    /**
+     * Get the index of an account in the sorted order.
+     * Returns -1 if account not found.
+     */
+    getIndex(pubkey: PublicKey): number;
+    /**
+     * Get sorted accounts according to transaction rules.
+     */
+    getSortedAccounts(): readonly AccountEntry[];
+    /**
+     * Get the message header based on sorted accounts.
+     */
+    getHeader(): MessageHeader;
+    /**
+     * Get sorted public keys.
+     */
+    getPublicKeys(): readonly PublicKey[];
+    /**
+     * Get number of accounts in table.
+     */
+    size(): number;
 }
+
 /**
- * Get signatures for address configuration.
+ * Error codes for transaction operations.
  */
-interface GetSignaturesForAddressConfig {
-    /** Maximum number of signatures to return */
-    limit?: number;
-    /** Start searching backwards from this signature */
-    before?: string;
-    /** Start searching forwards from this signature */
-    until?: string;
+declare enum TransactionErrorCode {
+    INVALID_INSTRUCTION = "INVALID_INSTRUCTION",
+    INVALID_ACCOUNT_META = "INVALID_ACCOUNT_META",
+    NO_INSTRUCTIONS = "NO_INSTRUCTIONS",
+    DUPLICATE_ACCOUNT = "DUPLICATE_ACCOUNT",
+    MISSING_SIGNATURE = "MISSING_SIGNATURE",
+    INVALID_SIGNATURE = "INVALID_SIGNATURE",
+    SIGNATURE_OUT_OF_BOUNDS = "SIGNATURE_OUT_OF_BOUNDS",
+    SIGNER_NOT_FOUND = "SIGNER_NOT_FOUND",
+    ALREADY_SIGNED = "ALREADY_SIGNED",
+    INVALID_MESSAGE_FORMAT = "INVALID_MESSAGE_FORMAT",
+    INSUFFICIENT_DATA = "INSUFFICIENT_DATA",
+    SERIALIZATION_FAILED = "SERIALIZATION_FAILED",
+    SIMULATION_FAILED = "SIMULATION_FAILED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    BLOCKHASH_EXPIRED = "BLOCKHASH_EXPIRED"
 }
 /**
- * Get signatures for address response.
+ * Error class for transaction operations with structured error information.
  */
-interface GetSignaturesForAddressResponse {
-    context: {
-        slot: bigint;
-        apiVersion: string;
+declare class TransactionError extends Error {
+    readonly code: TransactionErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: TransactionErrorCode, message: string, details?: Record<string, unknown> | undefined);
+    static noInstructions(): TransactionError;
+    static signerNotFound(pubkey: string): TransactionError;
+    static missingSignature(index: number, pubkey: string): TransactionError;
+    static simulationFailed(logs: string[], error: string): TransactionError;
+    static insufficientFunds(required: bigint, available: bigint): TransactionError;
+    toJSON(): {
+        code: TransactionErrorCode;
+        message: string;
+        details?: Record<string, unknown>;
     };
-    /** Array of signature information */
-    value: Array<{
-        signature: string;
-        blockHeight: bigint;
-        blockTime: bigint;
-        err?: string;
-    }>;
-}
-/**
- * Is blockhash valid response.
- */
-interface IsBlockhashValidResponse {
-    /** Whether the blockhash is valid */
-    value: boolean;
-}
-/**
- * Get health response.
- */
-type GetHealthResponse = "ok" | string;
-/**
- * Get validator health response.
- */
-type GetValidatorHealthResponse = "ok" | string;
-/**
- * Get connected full nodes response.
- */
-interface GetConnectedFullNodesResponse {
-    /** Array of connected nodes */
-    nodes: Array<{
-        publicKey: string;
-        connectedTime: bigint;
-    }>;
 }
+
 /**
- * Get transactions configuration.
- */
-interface GetTransactionsConfig {
-    /** Maximum number of transactions to return */
-    limit?: number;
-    /** Encoding format */
-    encoding?: "json" | "base58" | "base64";
-}
+ * Create an instruction with Borsh-encoded data.
+ *
+ * @example
+ * ```typescript
+ * // Define your instruction data class
+ * class MyInstructionData {
+ *   @field({ type: 'u8' })
+ *   instruction: number;
+ *
+ *   @field({ type: 'u64' })
+ *   amount: bigint;
+ *
+ *   @field({ type: option('string') })
+ *   memo?: string;
+ * }
+ *
+ * // Create instruction
+ * const instruction = createBorshInstruction({
+ *   programId: myProgramId,
+ *   accounts: [
+ *     { pubkey: account1, isSigner: true, isWritable: true },
+ *     { pubkey: account2, isSigner: false, isWritable: false },
+ *   ],
+ *   data: new MyInstructionData({
+ *     instruction: 5,
+ *     amount: 1000n,
+ *     memo: "Hello, Rialo!",
+ *   }),
+ * });
+ * ```
+ */
+declare function createBorshInstruction<T>(params: {
+    programId: PublicKey;
+    accounts: AccountMeta[];
+    data: T;
+}): Instruction;
 /**
- * Get transactions response.
+ * Helper for creating Borsh-serialized instruction data from a plain object.
+ *
+ * This is useful when you don't want to define a class with decorators.
+ *
+ * @example
+ * ```typescript
+ * const data = encodeBorshData({
+ *   instruction: { type: 'u8', value: 1 },
+ *   amount: { type: 'u64', value: 1000n },
+ *   recipient: { type: fixedArray('u8', 32), value: recipientBytes },
+ * });
+ * ```
  */
-interface GetTransactionsResponse {
-    /** Array of transaction data */
-    transactions: Array<Record<string, unknown>>;
-}
+declare function encodeBorshData(_schema: Record<string, {
+    type: unknown;
+    value: unknown;
+}>): Uint8Array;
+
 /**
- * Signature status from the RPC.
+ * System program instruction types.
  */
-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;
+declare enum SystemInstruction {
+    CreateAccount = 0,
+    Assign = 1,
+    Transfer = 2,
+    CreateAccountWithSeed = 3,
+    AdvanceNonceAccount = 4,
+    WithdrawNonceAccount = 5,
+    InitializeNonceAccount = 6,
+    AuthorizeNonceAccount = 7,
+    Allocate = 8,
+    AllocateWithSeed = 9,
+    AssignWithSeed = 10,
+    TransferWithSeed = 11
 }
 /**
- * Options for confirming a transaction.
+ * Create a transfer instruction.
+ *
+ * Transfers native tokens from one account to another.
+ *
+ * @param from - Source account (must be signer)
+ * @param to - Destination account
+ * @param amount - Amount to transfer in smallest denomination (kelvins)
+ *
+ * @example
+ * ```typescript
+ * const instruction = transferInstruction(fromPubkey, toPubkey, 1_000_000n);
+ *
+ * const tx = TransactionBuilder.create()
+ *   .setPayer(fromPubkey)
+ *   .addInstruction(instruction)
+ *   .build();
+ * ```
  */
-interface ConfirmTransactionOptions {
-    /** Maximum number of retry attempts (default: 30) */
-    maxRetries?: number;
-    /** Delay between retries in milliseconds (default: 1000) */
-    retryDelay?: number;
-}
+declare function transferInstruction(from: PublicKey, to: PublicKey, amount: bigint): Instruction;
 /**
- * Options for sending and confirming a transaction.
+ * Create an account creation instruction.
+ *
+ * @param from - Funding account (must be signer)
+ * @param newAccount - New account to create (must be signer)
+ * @param kelvins - Initial balance for new account
+ * @param space - Number of bytes to allocate for account data
+ * @param owner - Program that will own the new account
  */
-interface SendAndConfirmOptions extends SendTransactionOptions, ConfirmTransactionOptions {
-}
+declare function createAccount(from: PublicKey, newAccount: PublicKey, kelvins: bigint, space: bigint, owner: PublicKey): Instruction;
 /**
- * Result of a confirmed transaction.
+ * Create an allocate instruction.
+ *
+ * Allocates space for an account's data. The account must be owned by
+ * the system program and must sign the transaction.
+ *
+ * @param account - Account to allocate space for (must be signer)
+ * @param space - Number of bytes to allocate
  */
-interface ConfirmedTransaction {
-    /** Transaction signature */
-    signature: string;
-    /** Whether the transaction was executed */
-    executed: boolean;
-    /** Error message if transaction failed */
-    err?: string;
-}
-
+declare function allocateInstruction(account: PublicKey, space: bigint): Instruction;
 /**
- * Main Rialo RPC client for blockchain interactions.
+ * Create an assign instruction.
+ *
+ * Changes the owner of an account. The account must currently be owned
+ * by the system program and must sign the transaction.
+ *
+ * @param account - Account to reassign (must be signer)
+ * @param owner - New owner program
  */
+declare function assignInstruction(account: PublicKey, owner: PublicKey): Instruction;
 
 /**
- * High-level Rialo RPC client for blockchain interactions.
+ * An unsigned transaction message ready to be signed.
  *
- * Provides a unified interface for querying blockchain state and
- * sending transactions. Internally delegates to specialized clients
- * (QueryRpcClient, TransactionRpcClient) for modular organization.
+ * This is the data that gets signed by transaction signers.
+ * It's immutable to prevent accidental modification after creation.
  *
  * @example
  * ```typescript
- * import { createRialoClient, RIALO_DEVNET_CHAIN } from '@rialo/ts-cdk';
- *
- * const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });
- *
- * // Query operations
- * const balance = await client.getBalance(publicKey);
- * const chainId = client.getChainIdentifier();
+ * const message = MessageBuilder.create()
+ *   .setPayer(payer)
+ *   .setValidFrom(validFrom)
+ *   .addInstruction(transferInstruction)
+ *   .build();
  *
- * // Transaction operations
- * const signature = await client.sendTransaction(signedTx);
+ * // Serialize for signing
+ * const messageBytes = message.serialize();
  * ```
  */
-declare class RialoClient {
-    private readonly queryClient;
-    private readonly transactionClient;
-    private readonly transport;
-    private readonly chain;
-    constructor(transport: HttpTransport, chain: ChainDefinition);
-    /**
-     * Returns the configured RPC endpoint URL.
-     */
-    getUrl(): string;
-    /**
-     * 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.
-     *
-     * @returns Account info or null if account doesn't exist
-     */
-    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
-    /**
-     * Retrieves the current block height.
-     */
-    getBlockHeight(): Promise<bigint>;
+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[]);
     /**
-     * Retrieves the signatures for an address.
+     * Serialize message to bytes for signing.
+     * Result is cached for performance.
      */
-    getSignaturesForAddress(address: PublicKey, config?: GetSignaturesForAddressConfig): Promise<GetSignaturesForAddressResponse>;
+    serialize(): Uint8Array;
     /**
-     * Retrieves detailed information about a transaction.
+     * Deserialize a message from wire format.
      *
-     * @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.
+     * @param data - Serialized message bytes
+     * @returns Deserialized Message
      */
-    getEpochInfo(): Promise<EpochInfoResponse>;
+    static deserialize(data: Uint8Array): Message;
+    private serializeInternal;
+    private serializeCompactArray;
+    private serializeCompactU16;
     /**
-     * Checks the health status of the RPC node.
-     *
-     * @returns "ok" if healthy, error message otherwise
+     * Get all signers required for this message.
      */
-    getHealth(): Promise<"ok" | string>;
+    getSigners(): readonly PublicKey[];
     /**
-     * Submits a signed transaction to the blockchain.
-     *
-     * @param transaction - Serialized signed transaction bytes
-     * @param options - Transaction submission options
-     * @returns Transaction signature
+     * Check if a public key is a required signer.
      */
-    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
+    isSignerRequired(pubkey: PublicKey): boolean;
     /**
-     * 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
+     * Get the index of a signer in the signers array.
+     * Returns -1 if not a signer.
      */
-    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
-    /**
-     * 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
+    getSignerIndex(pubkey: PublicKey): number;
+}
+
+/**
+ * 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.
      *
-     * @example
-     * ```typescript
-     * const result = await client.sendAndConfirmTransaction(signedTx);
-     * console.log(`Confirmed in slot ${result.slot}`);
-     * ```
+     * @internal - Users should use TransactionBuilder instead
      */
-    sendAndConfirmTransaction(transaction: Uint8Array, options?: SendAndConfirmOptions): Promise<ConfirmedTransaction>;
+    static fromMessage(message: Message): Transaction;
     /**
-     * Waits for a transaction to be confirmed.
-     *
-     * @param signature - Transaction signature to monitor
-     * @param options - Confirmation options
-     * @returns Confirmed transaction details
+     * Create transaction from message and existing signatures.
+     * @internal
      */
-    confirmTransaction(signature: string, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
+    static fromMessageAndSignatures(message: Message, signatures: readonly Uint8Array[]): Transaction;
     /**
-     * Requests an airdrop and waits for confirmation.
-     *
-     * **Note**: Only available on devnet and testnet.
+     * Deserialize a transaction from wire format.
      */
-    requestAirdropAndConfirm(pubkey: PublicKey, amount: bigint, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
-}
-
-/**
- * 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 {
+    static deserialize(data: Uint8Array): Transaction;
+    getMessage(): Message;
     /**
-     * Retrieve the balance of an account in kelvins (smallest unit).
+     * Sign the transaction with a keypair.
+     * Returns a NEW Transaction instance.
      *
-     * @param pubkey - The public key of the account to query
-     * @returns The account balance in kelvins
+     * @param keypair - Keypair to sign with
+     * @returns New Transaction instance with signature added
      *
      * @example
      * ```typescript
-     * const balance = await client.getBalance(publicKey);
-     * console.log(`Balance: ${balance} kelvins`);
+     * const signedTx = tx.sign(keypair);
+     * await client.sendTransaction(signedTx.serialize());
      * ```
      */
-    getBalance(pubkey: PublicKey): Promise<bigint>;
+    sign(keypair: Keypair): Transaction;
     /**
-     * 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
+     * Sign with multiple keypairs at once.
+     * Returns a NEW Transaction instance.
      *
      * @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`);
-     * }
+     * const signed = tx.signAll([keypair1, keypair2, keypair3]);
      * ```
      */
-    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
+    signAll(keypairs: Keypair[]): Transaction;
     /**
-     * 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.
-     *
-     * @returns The current block height
+     * Sign the transaction with a Signer interface (async).
+     * Returns a NEW Transaction instance.
      *
      * @example
      * ```typescript
-     * const height = await client.getBlockHeight();
-     * console.log(`Current block height: ${height}`);
+     * const signedTx = await tx.signWith(browserWallet);
      * ```
      */
-    getBlockHeight(): Promise<bigint>;
+    signWith(signer: Signer): Promise<Transaction>;
     /**
-     * Retrieve transaction signatures for a given address.
-     *
-     * Returns transaction signatures with metadata associated with the specified
-     * address, ordered by slot height (most recent first).
-     *
-     * @param address - The public key of the address to query
-     * @param config - Optional configuration options for the query (limit, before, until)
-     * @returns Response containing context and array of signature info with blockHeight and blockTime
-     *
-     * @example
-     * ```typescript
-     * const result = await client.getSignaturesForAddress(publicKey, { limit: 10 });
-     * console.log(`Query slot: ${result.context.slot}`);
-     * result.value.forEach(sig => {
-     *   console.log(`Transaction: ${sig.signature}, block: ${sig.blockHeight}`);
-     * });
-     * ```
+     * Sign with multiple signers.
+     * Returns a NEW Transaction instance.
      */
-    getSignaturesForAddress(address: PublicKey, config?: GetSignaturesForAddressConfig): Promise<GetSignaturesForAddressResponse>;
+    signAllWith(signers: Signer[]): Promise<Transaction>;
     /**
-     * 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
+     * Partially sign the transaction (for multi-sig transactions).
+     * Returns a NEW Transaction instance.
      *
      * @example
      * ```typescript
-     * const tx = await client.getTransaction(signature);
-     * if (tx) {
-     *   console.log(`Confirmed in block: ${tx.blockHeight}`);
-     *   if (tx.err) {
-     *     console.log(`Transaction failed: ${tx.err}`);
-     *   }
-     * }
+     * const signedTx = tx
+     *   .partialSign(signer1)
+     *   .partialSign(signer2);
      * ```
      */
-    getTransaction(signature: string): Promise<TransactionResponse | null>;
+    partialSign(keypair: Keypair): Transaction;
     /**
-     * Retrieve the total number of transactions processed since genesis.
-     *
-     * @returns The total transaction count
-     *
-     * @example
-     * ```typescript
-     * const count = await client.getTransactionCount();
-     * console.log(`Total transactions: ${count}`);
-     * ```
+     * Partially sign with a Signer interface (async).
+     * Returns a NEW Transaction instance.
      */
-    getTransactionCount(): Promise<bigint>;
+    partialSignWith(signer: Signer): Promise<Transaction>;
     /**
-     * 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)
+     * Add a signature at a specific index.
+     * Returns a NEW Transaction instance.
      *
-     * @example
-     * ```typescript
-     * 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`);
-     *   }
-     * });
-     * ```
+     * Most users should use sign() or signAll() instead.
      */
-    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
+    addSignature(index: number, signature: Signature | Uint8Array): Transaction;
     /**
-     * Retrieve information about the current epoch.
-     *
-     * Returns epoch metadata including the current epoch number, slot position
-     * within the epoch, total slots per epoch, and current block height.
-     *
-     * @returns Current epoch information
+     * Add a signature for a specific public key.
+     * Returns a NEW Transaction instance.
      *
-     * @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}`);
-     * ```
+     * Most users should use sign() or signAll() instead.
      */
-    getEpochInfo(): Promise<EpochInfoResponse>;
+    addSignatureForPubkey(pubkey: PublicKey, signature: Signature | Uint8Array): Transaction;
     /**
-     * Check the health status of the RPC node.
-     *
-     * 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
-     * const health = await client.getHealth();
-     * if (health === "ok") {
-     *   console.log("Node is healthy");
-     * } else {
-     *   console.log(`Node unhealthy: ${health}`);
-     * }
-     * ```
+     * Check if transaction is fully signed (all signatures present).
      */
-    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 {
+    isSigned(): boolean;
     /**
-     * Submit a signed transaction to the blockchain.
-     *
-     * 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 transaction - Serialized signed transaction bytes
-     * @param options - Transaction submission options
-     * @returns Transaction signature (base58 encoded)
-     *
-     * @example
-     * ```typescript
-     * const signature = await client.sendTransaction(signedTx);
-     * console.log(`Submitted: ${signature}`);
-     *
-     * // With options
-     * const signature = await client.sendTransaction(signedTx, {
-     *   skipPreflight: true,
-     *   maxRetries: 3,
-     * });
-     * ```
+     * Check if a specific signature slot is filled.
      */
-    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
+    isSignaturePresent(index: number): boolean;
     /**
-     * Wait for a transaction to be confirmed.
-     *
-     * A transaction is considered confirmed when:
-     * - It has been processed in a block (`blockHeight > 0`)
-     *
-     * @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
+     * Get all signatures (returns copies to prevent mutation).
      */
-    confirmTransaction(signature: string, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
+    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;
     /**
-     * Submit a signed transaction and wait for confirmation.
-     *
-     * 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,
-     * });
-     * ```
+     * Get required signers for this transaction.
      */
-    sendAndConfirmTransaction(transaction: Uint8Array, options?: SendAndConfirmOptions): Promise<ConfirmedTransaction>;
+    getSigners(): readonly PublicKey[];
     /**
-     * Request an airdrop of tokens to an account.
-     *
-     * **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}`);
-     * ```
+     * Get the number of required signatures.
      */
-    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
+    getRequiredSignatureCount(): number;
     /**
-     * Request an airdrop of tokens and wait for confirmation.
-     *
-     * **Note**: Only available on devnet and testnet networks.
-     *
-     * Combines {@link requestAirdrop} and {@link confirmTransaction} into
-     * a single call for convenience.
+     * Throw an error if the transaction is not fully signed.
      *
-     * @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
+     * @throws {TransactionError} If transaction is not fully signed
      *
      * @example
      * ```typescript
-     * const result = await client.requestAirdropAndConfirm(publicKey, 1_000_000_000n);
-     * if (result.executed) {
-     *   console.log("Airdrop confirmed!");
-     * }
+     * signedTx.ensureSigned(); // Throws if not signed
+     * await client.sendTransaction(signedTx.serialize());
      * ```
      */
-    requestAirdropAndConfirm(pubkey: PublicKey, amount: bigint, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
-    private getTransaction;
+    ensureSigned(): void;
     /**
-     * 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.
+     * Serialize transaction to wire format.
      */
-    private sleep;
+    serialize(): Uint8Array;
 }
 
 /**
- * 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.
+ * Fluent API for building transactions.
+ * Returns Transaction directly (not Message).
  */
-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.
+ * Builder for creating transactions with a fluent API.
  *
- * @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
+ * Provides an intuitive interface for constructing transactions.
+ * Call build() to get an unsigned Transaction ready for signing.
  *
  * @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 }
- * });
+ * // Simple transfer
+ * const tx = TransactionBuilder.create()
+ *   .setPayer(payer)
+ *   .setValidFrom(validFrom)
+ *   .addInstruction(transfer(from, to, 1_000_000n))
+ *   .build();
  *
- * // With custom RPC URL
- * const client = createRialoClient({
- *   chain: {
- *     id: 'rialo:mainnet',
- *     name: 'Mainnet',
- *     rpcUrl: 'https://mainnet.custom-rpc.com:4101'
- *   },
- * });
+ * const signedTx = tx.sign(keypair);
+ * await client.transaction.sendTransaction(signedTx.serialize());
  * ```
- */
-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'
- *   },
- * });
+ * // 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 function getDefaultRialoClientConfig(network: RialoNetwork): RialoClientConfig;
+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;
+}
 
 /**
  * Converts bytes to base64 string.
@@ -2075,4 +2512,4 @@ declare function getMainnetUrl(): string;
  */
 declare function getLocalnetUrl(): string;
 
-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 };
+export { type AccountFilter, type AccountInfo, type AccountMeta, AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, type Bump, type ChainDefinition, type CompiledInstruction, type ConfirmTransactionOptions, type ConfirmedTransaction, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, type EpochInfoResponse, type EventData, type GetAccountsByOwnerConfig, type GetAccountsByOwnerResponse, type GetHealthResponse, type GetSignaturesForAddressConfig, type GetTransactionsConfig, type GetTransactionsResponse, type GetWorkflowLineageRequest, type GetWorkflowLineageResponse, HttpTransport, type HttpTransportConfig, type IdentifierString, type Instruction, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, type MessageHeader, Mnemonic, type MnemonicStrength, type OwnerAccount, type PDA, PUBLIC_KEY_LENGTH, type PaginationInfo, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_SHITNET_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 Seed, type SendAndConfirmOptions, type SendTransactionOptions, Signature, type SignatureInfo, type SignatureStatus, type Signer, type Subscription, type SubscriptionKind, SystemInstruction, type TimestampRange, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, type TransactionNodeData, type TransactionResponse, TransactionRpcClient, type TriggerInfo, type TriggeredTransaction, type TruncationReason, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_SHITNET, URL_TESTNET, type WorkflowLineage, type WorkflowNode, allocateInstruction, assignInstruction, calculateBackoff, concatBytes, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, isOnCurve, seedToBytes, sleep, toBase64, transferInstruction };