@rialo/ts-cdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1774 @@
+/**
+ * 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;
+}
+
+/** Default number of accounts to derive in HD wallets */
+declare const DEFAULT_NUM_ACCOUNTS: number;
+/** Rialo mainnet RPC URL */
+declare const URL_MAINNET: string;
+/** Rialo testnet RPC URL */
+declare const URL_TESTNET: string;
+/** Rialo devnet RPC URL */
+declare const URL_DEVNET: string;
+/** Rialo localnet RPC URL */
+declare const URL_LOCALNET: string;
+/** System program ID */
+declare const SYSTEM_PROGRAM_ID: string;
+/** Base derivation path for Rialo wallets (BIP44 coin type 756) */
+/** Coin type 756 follows the telephone keypad convention: R=7, L=5, O=6 */
+declare const BASE_DERIVATION_PATH: string;
+declare const KELVIN_PER_RLO: number;
+declare const PUBLIC_KEY_LENGTH: number;
+declare const SECRET_KEY_LENGTH: number;
+declare const SIGNATURE_LENGTH: number;
+declare const BLOCKHASH_LENGTH: number;
+
+/**
+ * Represents a 32-byte blockhash used for transaction replay protection.
+ *
+ * @example
+ * ```typescript
+ * // From RPC response
+ * const blockhash = Blockhash.fromString(rpcBlockhash);
+ *
+ * // Comparison
+ * if (blockhash1.equals(blockhash2)) {
+ *   console.log("Same blockhash");
+ * }
+ * ```
+ */
+declare class Blockhash {
+    private readonly bytes;
+    private constructor();
+    /**
+     * Creates a Blockhash from raw bytes.
+     *
+     * @param bytes - 32-byte blockhash
+     * @throws {CryptoError} If bytes length is not 32
+     */
+    static fromBytes(bytes: Uint8Array): Blockhash;
+    /**
+     * Creates a Blockhash from a base58-encoded string.
+     *
+     * @param str - Base58-encoded blockhash
+     * @throws {CryptoError} If string is invalid or decodes to wrong length
+     */
+    static fromString(str: string): Blockhash;
+    /**
+     * Returns a copy of the raw bytes.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the base58-encoded string representation.
+     */
+    toString(): string;
+    /**
+     * Checks equality with another blockhash using constant-time comparison.
+     */
+    equals(other: Blockhash): boolean;
+    /**
+     * JSON serialization (returns base58 string).
+     */
+    toJSON(): string;
+}
+
+/**
+ * Error codes for cryptographic operations.
+ */
+declare enum CryptoErrorCode {
+    INVALID_KEY_LENGTH = "INVALID_KEY_LENGTH",
+    INVALID_SIGNATURE = "INVALID_SIGNATURE",
+    INVALID_PUBLIC_KEY = "INVALID_PUBLIC_KEY",
+    INVALID_BLOCKHASH = "INVALID_BLOCKHASH",
+    INVALID_MNEMONIC = "INVALID_MNEMONIC",
+    KEY_DERIVATION_FAILED = "KEY_DERIVATION_FAILED",
+    KEYPAIR_DISPOSED = "KEYPAIR_DISPOSED"
+}
+/**
+ * Error class for cryptographic operations.
+ *
+ * Provides structured error information with error codes and contextual details
+ * for better debugging and error handling.
+ */
+declare class CryptoError extends Error {
+    readonly code: CryptoErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(code: CryptoErrorCode, message: string, details?: Record<string, unknown>);
+    static invalidKeyLength(expected: number, actual: number): CryptoError;
+    static invalidMnemonic(reason?: string): CryptoError;
+    static keyDerivationFailed(path: string, cause?: Error): CryptoError;
+    static keypairDisposed(): CryptoError;
+}
+
+/**
+ * Represents a 64-byte Ed25519 signature.
+ *
+ * @example
+ * ```typescript
+ * // From bytes
+ * const sig = Signature.fromBytes(signatureBytes);
+ *
+ * // From base58 string
+ * const sig = Signature.fromString("3Bxs4h...");
+ *
+ * // Serialize
+ * const base58 = sig.toString();
+ * ```
+ */
+declare class Signature {
+    private readonly bytes;
+    private constructor();
+    /**
+     * Creates a Signature from raw bytes.
+     *
+     * @param bytes - 64-byte Ed25519 signature
+     * @throws {CryptoError} If bytes length is not 64
+     */
+    static fromBytes(bytes: Uint8Array): Signature;
+    /**
+     * Creates a Signature from a base58-encoded string.
+     *
+     * @param str - Base58-encoded signature
+     * @throws {CryptoError} If string is invalid or decodes to wrong length
+     */
+    static fromString(str: string): Signature;
+    /**
+     * Returns a copy of the raw bytes.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the base58-encoded string representation.
+     */
+    toString(): string;
+    /**
+     * JSON serialization (returns base58 string).
+     */
+    toJSON(): string;
+}
+
+/**
+ * Represents a 32-byte Ed25519 public key.
+ *
+ * @example
+ * ```typescript
+ * // From base58 string
+ * const pubkey = PublicKey.fromString("5ZqB9U...");
+ *
+ * // From bytes
+ * const pubkey = PublicKey.fromBytes(new Uint8Array(32));
+ *
+ * // Comparison
+ * if (pubkey1.equals(pubkey2)) {
+ *   console.log("Keys match");
+ * }
+ * ```
+ */
+declare class PublicKey {
+    private readonly bytes;
+    private constructor();
+    /**
+     * Creates a PublicKey from raw bytes.
+     *
+     * @param bytes - 32-byte Ed25519 public key
+     * @throws {CryptoError} If bytes length is not 32
+     */
+    static fromBytes(bytes: Uint8Array): PublicKey;
+    /**
+     * Creates a PublicKey from a base58-encoded string.
+     *
+     * @param str - Base58-encoded public key
+     * @throws {CryptoError} If string is invalid or decodes to wrong length
+     */
+    static fromString(str: string): PublicKey;
+    /**
+     * Returns a copy of the raw bytes.
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Returns the base58-encoded string representation.
+     */
+    toString(): string;
+    /**
+     * Checks equality with another public key using constant-time comparison.
+     */
+    equals(other: PublicKey): boolean;
+    /**
+     * Verifies an Ed25519 signature over a message.
+     *
+     * @param message - Message bytes that were signed
+     * @param signature - Signature to verify
+     * @returns True if signature is valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const message = new Uint8Array([1, 2, 3]);
+     * const signature = keypair.sign(message);
+     * const isValid = keypair.publicKey.verify(message, signature);
+     * ```
+     */
+    verify(message: Uint8Array, signature: Signature): boolean;
+    /**
+     * JSON serialization (returns base58 string).
+     */
+    toJSON(): string;
+}
+
+/**
+ * Represents an Ed25519 keypair for signing transactions.
+ *
+ * Provides secure key generation, signing, and disposal capabilities.
+ * Call {@link dispose} when finished to securely erase the private key from memory.
+ *
+ * @example
+ * ```typescript
+ * // Generate random keypair
+ * const keypair = Keypair.generate();
+ *
+ * // Sign a message
+ * const message = new TextEncoder().encode("Hello");
+ * const signature = keypair.sign(message);
+ *
+ * // Verify signature
+ * const isValid = keypair.verify(message, signature);
+ *
+ * // Secure cleanup
+ * keypair.dispose();
+ * ```
+ */
+declare class Keypair {
+    readonly publicKey: PublicKey;
+    private secretKey;
+    private disposed;
+    private constructor();
+    /**
+     * Generates a random keypair using cryptographically secure randomness.
+     */
+    static generate(): Keypair;
+    /**
+     * Creates a keypair from a 32-byte secret key.
+     * The public key will be derived from the secret key.
+     *
+     * @param secretKey - 32-byte Ed25519 secret key
+     */
+    static fromSecretKey(secretKey: Uint8Array): Keypair;
+    /**
+     * Creates a keypair from a secret key and pre-computed public key.
+     *
+     * Use this for SLIP-0010/BIP32 derived keys where the public key
+     * should NOT be re-derived (compatibility with hierarchical derivation).
+     *
+     * @param secretKey - 32-byte Ed25519 secret key
+     * @param publicKey - 32-byte Ed25519 public key (pre-computed)
+     */
+    static fromKeyPair(secretKey: Uint8Array, publicKey: Uint8Array): Keypair;
+    /**
+     * Signs a message with this keypair.
+     *
+     * @param message - Message bytes to sign
+     * @returns Ed25519 signature
+     * @throws {CryptoError} If keypair has been disposed
+     */
+    sign(message: Uint8Array): Signature;
+    /**
+     * Verifies a signature against a message using this keypair's public key.
+     *
+     * @param message - Original message that was signed
+     * @param signature - Signature to verify
+     * @returns true if signature is valid
+     */
+    verify(message: Uint8Array, signature: Signature): boolean;
+    /**
+     * Exports the secret key for storage.
+     *
+     * **WARNING**: Keep this secret! Never expose it in logs, APIs, or client-side code.
+     *
+     * @returns Copy of the 32-byte secret key
+     * @throws {CryptoError} If keypair has been disposed
+     */
+    secretKeyBytes(): Uint8Array;
+    /**
+     * Checks if this keypair has been disposed.
+     */
+    isDisposed(): boolean;
+    /**
+     * Securely erases the secret key from memory.
+     *
+     * After calling this method, the keypair can no longer be used for signing.
+     * This is important for security when the keypair is no longer needed.
+     */
+    dispose(): void;
+    private ensureNotDisposed;
+}
+
+type MnemonicStrength = 128 | 256;
+/**
+ * Represents a validated BIP39 mnemonic phrase with SLIP-0010 Ed25519 hierarchical key derivation.
+ *
+ * Implements the SLIP-0010 standard for Ed25519 key derivation, ensuring compatibility
+ * with other implementations (e.g., Rust CDK). The default derivation path uses coin type
+ * 756 (R=7, L=5, O=6 on telephone keypad).
+ *
+ * @example
+ * ```typescript
+ * // Generate new mnemonic (12 or 24 words)
+ * const mnemonic = Mnemonic.generate(128); // 12 words
+ *
+ * // Restore from existing phrase
+ * const restored = Mnemonic.fromPhrase("word1 word2 ...");
+ *
+ * // Derive keypairs at specific account indices
+ * const keypair0 = await mnemonic.toKeypair(0); // m/44'/756'/0'/0'
+ * const keypair1 = await mnemonic.toKeypair(1); // m/44'/756'/1'/0'
+ *
+ * // With custom passphrase (BIP39 extension)
+ * const secure = await mnemonic.toKeypair(0, {
+ *   passphrase: "my-secret"
+ * });
+ * ```
+ *
+ * @see {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md SLIP-0010 Specification}
+ */
+declare class Mnemonic {
+    private readonly phrase;
+    private constructor();
+    /**
+     * Generates a new random BIP39 mnemonic phrase.
+     *
+     * @param strength - Entropy strength (128 = 12 words, 256 = 24 words). Default: 128
+     * @returns Validated Mnemonic instance
+     */
+    static generate(strength?: MnemonicStrength): Mnemonic;
+    /**
+     * Creates a Mnemonic from an existing phrase.
+     *
+     * @param phrase - BIP39 mnemonic phrase (12 or 24 space-separated words)
+     * @returns Validated Mnemonic instance
+     * @throws {CryptoError} If phrase is invalid (wrong words or checksum)
+     */
+    static fromPhrase(phrase: string): Mnemonic;
+    /**
+     * Validates a phrase without creating an instance.
+     *
+     * Checks both word validity and BIP39 checksum.
+     *
+     * @param phrase - Mnemonic phrase to validate
+     * @returns true if phrase is valid
+     */
+    static isValid(phrase: string): boolean;
+    private getMasterKeyFromSeed;
+    private deriveChildKey;
+    private derivePath;
+    /**
+     * Derives a keypair at a specific account index.
+     *
+     * Uses SLIP-0010 Ed25519 derivation with the default path:
+     * `m/44'/756'/{accountIndex}'/0'`
+     *
+     * Coin type 756 follows the telephone keypad convention (R=7, L=5, O=6).
+     *
+     * @param accountIndex - Account index to derive (default: 0)
+     * @param options - Derivation options
+     * @param options.passphrase - Optional BIP39 passphrase for additional security
+     * @param options.baseDerivationPath - Base path (default: "m/44'/756'")
+     * @returns Keypair for the derived account
+     */
+    toKeypair(accountIndex?: number, options?: {
+        passphrase?: string;
+        baseDerivationPath?: string;
+    }): Promise<Keypair>;
+    /**
+     * Derives a keypair using an explicit full derivation path.
+     *
+     * @param fullPath - Complete derivation path (e.g., "m/44'/756'/0'/0'")
+     * @param passphrase - Optional BIP39 passphrase
+     */
+    toKeypairWithPath(fullPath: string, passphrase?: string): Promise<Keypair>;
+    /**
+     * Derives multiple keypairs sequentially from this mnemonic.
+     *
+     * @param count - Number of keypairs to derive
+     * @param startIndex - Starting account index (default: 0)
+     * @param options - Derivation options (passphrase and path)
+     */
+    deriveKeypairs(count: number, startIndex?: number, options?: {
+        passphrase?: string;
+        baseDerivationPath?: string;
+    }): Promise<Keypair[]>;
+    /**
+     * Converts the mnemonic to a BIP39 seed.
+     *
+     * @param passphrase - Optional BIP39 passphrase for additional security
+     * @returns 64-byte seed
+     */
+    toSeed(passphrase?: string): Promise<Uint8Array>;
+    /**
+     * Returns the mnemonic phrase as a string.
+     */
+    toString(): string;
+    /**
+     * Returns the individual words of the mnemonic.
+     */
+    getWords(): string[];
+    /**
+     * Returns the word count (12 or 24).
+     */
+    getWordCount(): 12 | 24;
+    /**
+     * Returns the entropy strength (128 or 256 bits).
+     */
+    getStrength(): MnemonicStrength;
+    /**
+     * Checks equality with another mnemonic using constant-time comparison.
+     */
+    equals(other: Mnemonic): boolean;
+    /**
+     * JSON serialization (returns the mnemonic phrase).
+     */
+    toJSON(): string;
+    private buildFullPath;
+}
+
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * Message header containing signature requirements.
+ */
+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;
+}
+/**
+ * Compiled instruction with account indices.
+ */
+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;
+}
+
+/**
+ * Account metadata table for deduplication and sorting.
+ * Avoids: Complex account sorting logic scattered throughout builder
+ */
+
+/**
+ * Internal account entry with aggregated metadata.
+ */
+interface AccountEntry {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+/**
+ * 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.
+ */
+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;
+}
+
+/**
+ * Error codes for transaction operations.
+ */
+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"
+}
+/**
+ * Error class for transaction operations with structured error information.
+ */
+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>;
+    };
+}
+
+/**
+ * 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;
+/**
+ * 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 },
+ * });
+ * ```
+ */
+declare function encodeBorshData(_schema: Record<string, {
+    type: unknown;
+    value: unknown;
+}>): Uint8Array;
+
+/**
+ * System program instruction types.
+ */
+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
+}
+/**
+ * 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)
+ *   .setRecentBlockhash(blockhash)
+ *   .addInstruction(instruction)
+ *   .build();
+ * ```
+ */
+declare function transferInstruction(from: PublicKey, to: PublicKey, amount: bigint): Instruction;
+/**
+ * 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
+ */
+declare function createAccount(from: PublicKey, newAccount: PublicKey, lamports: bigint, space: bigint, owner: PublicKey): Instruction;
+
+interface HttpTransportConfig {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Base delay for exponential backoff (ms) */
+    retryBaseDelay?: number;
+    /** Maximum retry delay (ms) */
+    retryMaxDelay?: number;
+    /** Custom headers to include in requests */
+    headers?: Record<string, string>;
+}
+/**
+ * HTTP transport with built-in retry logic and timeout handling.
+ *
+ * Features:
+ * - Automatic retries with exponential backoff
+ * - Request timeouts using AbortController
+ * - Network error recovery
+ * - Rate limit handling
+ * - Proper HTTP status code handling
+ */
+declare class HttpTransport {
+    private readonly url;
+    private readonly config;
+    constructor(url: string, config?: HttpTransportConfig);
+    /**
+     * Makes an HTTP request with automatic retry logic.
+     *
+     * Retries are attempted for network errors and server errors (5xx).
+     * Uses exponential backoff between retry attempts.
+     */
+    request(body: string, requestDetails?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Make a single HTTP request with timeout
+     */
+    private makeRequest;
+    /**
+     * Handle HTTP error responses
+     */
+    private handleHttpError;
+    /**
+     * Returns the configured RPC endpoint URL.
+     */
+    getUrl(): string;
+}
+
+/**
+ * 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;
+    /**
+     * 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;
+    /** Slot in which the transaction was processed */
+    slot: bigint;
+    /** Block time (Unix timestamp) */
+    blockTime?: bigint;
+    /** Error message if transaction failed */
+    err?: string;
+}
+/**
+ * Signature status.
+ */
+interface SignatureStatus {
+    /** Slot in which the transaction was processed */
+    slot: bigint;
+    /** Number of confirmations */
+    confirmations?: number;
+    /** 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;
+}
+/**
+ * Fee for message response.
+ */
+interface GetFeeForMessageResponse {
+    /** Fee in smallest denomination */
+    value: bigint;
+}
+/**
+ * Multiple accounts response.
+ */
+interface MultipleAccountsResponse {
+    /** Array of account information */
+    value: Array<AccountInfo | null>;
+}
+/**
+ * Get subscriptions response.
+ */
+interface GetSubscriptionsResponse {
+    /** Array of subscription data */
+    subscriptions: Array<Record<string, unknown>>;
+}
+/**
+ * Get triggered transactions response.
+ */
+interface GetTriggeredTransactionsResponse {
+    /** Array of triggered transaction data */
+    transactions: Array<Record<string, unknown>>;
+}
+/**
+ * Get workflow lineage request.
+ */
+interface GetWorkflowLineageRequest {
+    /** Workflow account public key */
+    workflowAccount: PublicKey;
+    /** Optional limit on results */
+    limit?: number;
+}
+/**
+ * Get workflow lineage response.
+ */
+interface GetWorkflowLineageResponse {
+    /** Workflow lineage data */
+    lineage: Array<Record<string, unknown>>;
+}
+/**
+ * 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;
+}
+/**
+ * Get signatures for address response.
+ */
+interface GetSignaturesForAddressResponse {
+    /** Array of signature information */
+    signatures: Array<{
+        signature: string;
+        slot: bigint;
+        err?: string;
+        memo?: string;
+        blockTime?: bigint;
+    }>;
+}
+/**
+ * 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";
+}
+/**
+ * Get transactions response.
+ */
+interface GetTransactionsResponse {
+    /** Array of transaction data */
+    transactions: Array<Record<string, unknown>>;
+}
+
+/**
+ * Main Rialo RPC client for blockchain interactions.
+ */
+
+/**
+ * High-level Rialo RPC client for blockchain interactions.
+ *
+ * Provides a unified interface for querying blockchain state and
+ * sending transactions. Internally delegates to specialized clients
+ * (QueryRpcClient, TransactionRpcClient) for modular organization.
+ *
+ * @example
+ * ```typescript
+ * const client = createRialoClient(URL_DEVNET);
+ *
+ * // Query operations
+ * const balance = await client.getBalance(publicKey);
+ * const blockhash = await client.getLatestBlockhash();
+ *
+ * // Transaction operations
+ * const signature = await client.sendTransaction(signedTx);
+ * ```
+ */
+declare class RialoClient {
+    private readonly queryClient;
+    private readonly transactionClient;
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    /**
+     * Returns the configured RPC endpoint URL.
+     */
+    getUrl(): string;
+    /**
+     * Retrieves the latest blockhash from the blockchain.
+     *
+     * Required for transaction creation and replay protection.
+     */
+    getLatestBlockhash(): Promise<Blockhash>;
+    /**
+     * Retrieves the balance of an account in kelvins (smallest unit).
+     */
+    getBalance(pubkey: PublicKey): Promise<bigint>;
+    /**
+     * Retrieves detailed information about an account.
+     *
+     * @returns Account info or null if account doesn't exist
+     */
+    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
+    /**
+     * Retrieves the current block height.
+     */
+    getBlockHeight(): Promise<bigint>;
+    /**
+     * Retrieves detailed information about a transaction.
+     *
+     * @returns Transaction info or null if transaction not found
+     */
+    getTransaction(signature: string): Promise<TransactionResponse | null>;
+    /**
+     * Retrieves the total number of transactions processed since genesis.
+     */
+    getTransactionCount(): Promise<bigint>;
+    /**
+     * Retrieves the status of multiple transaction signatures.
+     */
+    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
+    /**
+     * Retrieves current epoch information.
+     */
+    getEpochInfo(): Promise<EpochInfoResponse>;
+    /**
+     * Checks the health status of the RPC node.
+     *
+     * @returns "ok" if healthy, error message otherwise
+     */
+    getHealth(): Promise<"ok" | string>;
+    /**
+     * Submits a signed transaction to the blockchain.
+     *
+     * @param transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission options
+     * @returns Transaction signature
+     */
+    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
+    /**
+     * Requests an airdrop of tokens to an account.
+     *
+     * **Note**: Only available on devnet and testnet.
+     *
+     * @param pubkey - Account to receive the airdrop
+     * @param amount - Amount in kelvins (smallest unit)
+     * @returns Transaction signature
+     */
+    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
+}
+
+/**
+ * Query client for read-only RPC operations.
+ */
+
+/**
+ * Client for querying blockchain state.
+ *
+ * Handles all read-only operations like getting balances, account info, etc.
+ */
+declare class QueryRpcClient extends BaseRpcClient {
+    /**
+     * Get the latest blockhash from the blockchain
+     */
+    getLatestBlockhash(): Promise<Blockhash>;
+    /**
+     * Get the balance of an account
+     */
+    getBalance(pubkey: PublicKey): Promise<bigint>;
+    /**
+     * Get detailed information about an account
+     */
+    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
+    /**
+     * Get the current block height
+     */
+    getBlockHeight(): Promise<bigint>;
+    /**
+     * Get detailed information about a transaction
+     */
+    getTransaction(signature: string): Promise<TransactionResponse | null>;
+    /**
+     * Get the total number of transactions processed since genesis
+     */
+    getTransactionCount(): Promise<bigint>;
+    /**
+     * Get the status of multiple transaction signatures
+     */
+    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
+    /**
+     * Get epoch information
+     */
+    getEpochInfo(): Promise<EpochInfoResponse>;
+    /**
+     * Get the health status of the node
+     */
+    getHealth(): Promise<"ok" | string>;
+}
+
+/**
+ * Query client for read-only RPC operations.
+ */
+
+/**
+ * Client for sending/simulating transactions and requesting airdrops.
+ *
+ * Handles all transaction operations like sending transactions, requesting airdrops, etc.
+ */
+declare class TransactionRpcClient extends BaseRpcClient {
+    /**
+     * Submit a signed transaction to the blockchain
+     */
+    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
+    /**
+     * Request an airdrop of tokens to an account (devnet/testnet only)
+     */
+    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
+}
+
+/**
+ * Error codes for RPC operations, categorized by type.
+ */
+declare enum RpcErrorCode {
+    REQUEST_TIMEOUT = "REQUEST_TIMEOUT",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    CONNECTION_REFUSED = "CONNECTION_REFUSED",
+    INVALID_RESPONSE = "INVALID_RESPONSE",
+    PARSE_ERROR = "PARSE_ERROR",
+    INVALID_REQUEST = "INVALID_REQUEST",
+    METHOD_NOT_FOUND = "METHOD_NOT_FOUND",
+    INVALID_PARAMS = "INVALID_PARAMS",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    TRANSACTION_REJECTED = "TRANSACTION_REJECTED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    ACCOUNT_NOT_FOUND = "ACCOUNT_NOT_FOUND",
+    BLOCKHASH_NOT_FOUND = "BLOCKHASH_NOT_FOUND",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    NODE_UNHEALTHY = "NODE_UNHEALTHY"
+}
+/**
+ * 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;
+    };
+}
+
+/**
+ * RPC client module for communicating with Rialo blockchain nodes.
+ *
+ * Provides a high-level client interface with automatic retry logic,
+ * connection management, and type-safe RPC methods.
+ *
+ * @example
+ * ```typescript
+ * import { createRialoClient, URL_DEVNET } from '@rialo/ts-cdk';
+ *
+ * // Create client with custom configuration
+ * const client = createRialoClient(URL_DEVNET, {
+ *   timeout: 30000,
+ *   maxRetries: 3,
+ * });
+ *
+ * // Query blockchain state
+ * const balance = await client.getBalance(publicKey);
+ * const blockHeight = await client.getBlockHeight();
+ *
+ * // Send transactions
+ * const signature = await client.sendTransaction(signedTx);
+ * ```
+ */
+
+/**
+ * Creates an RPC client with automatic retry and timeout handling.
+ *
+ * @param url - RPC endpoint URL (e.g., URL_DEVNET, URL_MAINNET)
+ * @param config - Transport configuration (timeout, retries, headers)
+ * @returns Configured RialoClient instance
+ */
+declare function createRialoClient(url: string, config?: HttpTransportConfig): RialoClient;
+
+/**
+ * An unsigned transaction message ready to be signed.
+ *
+ * This is the data that gets signed by transaction signers.
+ * It's immutable to prevent accidental modification after creation.
+ *
+ * @example
+ * ```typescript
+ * const message = MessageBuilder.create()
+ *   .setPayer(payer)
+ *   .setRecentBlockhash(blockhash)
+ *   .setCreationTime(txCreationTime)
+ *   .addInstruction(transferInstruction)
+ *   .build();
+ *
+ * // Serialize for signing
+ * const messageBytes = message.serialize();
+ * ```
+ */
+declare class Message {
+    /** Message header with signature requirements */
+    readonly header: MessageHeader;
+    /** All account public keys referenced in the transaction */
+    readonly accountKeys: readonly PublicKey[];
+    /** Recent blockhash for replay protection */
+    readonly recentBlockhash: Blockhash;
+    /** Transaction creation timestamp (milliseconds since Unix epoch) */
+    txCreationTime?: bigint;
+    /** Compiled instructions with account indices */
+    readonly instructions: readonly CompiledInstruction[];
+    /** Cached serialized bytes */
+    private serializedCache?;
+    constructor(header: MessageHeader, accountKeys: readonly PublicKey[], recentBlockhash: Blockhash, txCreationTime: bigint, instructions: readonly CompiledInstruction[]);
+    /**
+     * Serialize message to bytes for signing.
+     * Result is cached for performance.
+     */
+    serialize(): Uint8Array;
+    /**
+     * Deserialize a message from wire format.
+     *
+     * @param data - Serialized message bytes
+     * @returns Deserialized Message
+     */
+    static deserialize(data: Uint8Array): Message;
+    private serializeInternal;
+    private serializeCompactArray;
+    private serializeCompactU16;
+    /**
+     * Get all signers required for this message.
+     */
+    getSigners(): readonly PublicKey[];
+    /**
+     * Check if a public key is a required signer.
+     */
+    isSignerRequired(pubkey: PublicKey): boolean;
+    /**
+     * Get the index of a signer in the signers array.
+     * Returns -1 if not a signer.
+     */
+    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 {
+    /**
+     * Retrieves the signer's public key.
+     *
+     * **Note**: May trigger wallet connection prompts for browser wallets.
+     */
+    getPublicKey(): Promise<PublicKey>;
+    /**
+     * Signs arbitrary message bytes.
+     *
+     * @param message - Message bytes to sign
+     * @returns Ed25519 signature over the message
+     */
+    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);
+    /**
+     * Returns the keypair's public key.
+     */
+    getPublicKey(): Promise<PublicKey>;
+    /**
+     * Signs a message using the keypair's private key.
+     */
+    signMessage(message: Uint8Array): Promise<Signature>;
+}
+
+/**
+ * A transaction with zero or more signatures.
+ *
+ * Transactions are immutable - signing methods return new instances.
+ * This prevents accidental modification and signature tampering.
+ *
+ * @example
+ * ```typescript
+ * // Simple signing
+ * const tx = builder.build();
+ * const signed = tx.sign(keypair);
+ *
+ * // Method chaining
+ * const signed = tx
+ *   .sign(keypair1)
+ *   .sign(keypair2)
+ *   .sign(keypair3);
+ *
+ * // Multi-sig convenience
+ * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+ * ```
+ */
+declare class Transaction {
+    /** The unsigned message */
+    private readonly message;
+    /** Signatures (64 bytes each), aligned with message.header.numRequiredSignatures */
+    private readonly signatures;
+    private constructor();
+    /**
+     * Create an unsigned transaction from a message.
+     * All signature slots are initialized to zero.
+     *
+     * @internal - Users should use TransactionBuilder instead
+     */
+    static fromMessage(message: Message): Transaction;
+    /**
+     * Create transaction from message and existing signatures.
+     * @internal
+     */
+    static fromMessageAndSignatures(message: Message, signatures: readonly Uint8Array[]): Transaction;
+    /**
+     * Deserialize a transaction from wire format.
+     */
+    static deserialize(data: Uint8Array): Transaction;
+    getMessage(): Message;
+    /**
+     * Sign the transaction with a keypair.
+     * Returns a NEW Transaction instance.
+     *
+     * @param keypair - Keypair to sign with
+     * @returns New Transaction instance with signature added
+     *
+     * @example
+     * ```typescript
+     * const signedTx = tx.sign(keypair);
+     * await client.sendTransaction(signedTx.serialize());
+     * ```
+     */
+    sign(keypair: Keypair): Transaction;
+    /**
+     * Sign with multiple keypairs at once.
+     * Returns a NEW Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+     * ```
+     */
+    signAll(keypairs: Keypair[]): Transaction;
+    /**
+     * Sign the transaction with a Signer interface (async).
+     * Returns a NEW Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = await tx.signWith(browserWallet);
+     * ```
+     */
+    signWith(signer: Signer): Promise<Transaction>;
+    /**
+     * Sign with multiple signers.
+     * Returns a NEW Transaction instance.
+     */
+    signAllWith(signers: Signer[]): Promise<Transaction>;
+    /**
+     * Partially sign the transaction (for multi-sig transactions).
+     * Returns a NEW Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = tx
+     *   .partialSign(signer1)
+     *   .partialSign(signer2);
+     * ```
+     */
+    partialSign(keypair: Keypair): Transaction;
+    /**
+     * Partially sign with a Signer interface (async).
+     * Returns a NEW Transaction instance.
+     */
+    partialSignWith(signer: Signer): Promise<Transaction>;
+    /**
+     * Add a signature at a specific index.
+     * Returns a NEW Transaction instance.
+     *
+     * Most users should use sign() or signAll() instead.
+     */
+    addSignature(index: number, signature: Signature | Uint8Array): Transaction;
+    /**
+     * Add a signature for a specific public key.
+     * Returns a NEW Transaction instance.
+     *
+     * Most users should use sign() or signAll() instead.
+     */
+    addSignatureForPubkey(pubkey: PublicKey, signature: Signature | Uint8Array): Transaction;
+    /**
+     * Check if transaction is fully signed (all signatures present).
+     */
+    isSigned(): boolean;
+    /**
+     * Check if a specific signature slot is filled.
+     */
+    isSignaturePresent(index: number): boolean;
+    /**
+     * Get all signatures (returns copies to prevent mutation).
+     */
+    getSignatures(): readonly Uint8Array[];
+    /**
+     * Get a specific signature (returns copy).
+     */
+    getSignature(index: number): Uint8Array;
+    /**
+     * Get a specific signature for a public key.
+     */
+    getSignatureForPubkey(pubkey: PublicKey): Uint8Array;
+    /**
+     * Get required signers for this transaction.
+     */
+    getSigners(): readonly PublicKey[];
+    /**
+     * Get the number of required signatures.
+     */
+    getRequiredSignatureCount(): number;
+    /**
+     * Throw an error if the transaction is not fully signed.
+     *
+     * @throws {TransactionError} If transaction is not fully signed
+     *
+     * @example
+     * ```typescript
+     * signedTx.ensureSigned(); // Throws if not signed
+     * await client.sendTransaction(signedTx.serialize());
+     * ```
+     */
+    ensureSigned(): void;
+    /**
+     * Serialize transaction to wire format.
+     */
+    serialize(): Uint8Array;
+}
+
+/**
+ * Fluent API for building transactions.
+ * Returns Transaction directly (not Message).
+ */
+
+/**
+ * Builder for creating transactions with a fluent API.
+ *
+ * Provides an intuitive interface for constructing transactions.
+ * Call build() to get an unsigned Transaction ready for signing.
+ *
+ * @example
+ * ```typescript
+ * // Simple transfer
+ * const tx = TransactionBuilder.create()
+ *   .setPayer(payer)
+ *   .setRecentBlockhash(blockhash)
+ *   .setTxCreationTime(txCreationTime)
+ *   .addInstruction(transfer(from, to, 1_000_000n))
+ *   .build();
+ *
+ * const signedTx = tx.sign(keypair);
+ * await client.transaction.sendTransaction(signedTx.serialize());
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multi-instruction transaction
+ * const tx = TransactionBuilder.create()
+ *   .setPayer(payer)
+ *   .setRecentBlockhash(blockhash)
+ *   .setTxCreationTime(txCreationTime)
+ *   .addInstruction(transfer(from, to, 1_000_000n))
+ *   .addInstruction(memoInstruction("Payment for invoice #123"))
+ *   .build();
+ * ```
+ */
+declare class TransactionBuilder {
+    private payer?;
+    private recentBlockhash?;
+    private txCreationTime?;
+    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 recent blockhash for replay protection.
+     *
+     * Get this from client.getLatestBlockhash().
+     * Transactions are only valid for ~60 seconds after the blockhash.
+     *
+     * @param blockhash - Recent blockhash from the network
+     */
+    setRecentBlockhash(blockhash: Blockhash): this;
+    /**
+     * Set the transaction creation timestamp.
+     *
+     * This is the time the transaction was created, in milliseconds since Unix epoch.
+     * It can be used for additional replay protection or auditing.
+     *
+     * @param txCreationTime - Transaction creation time in milliseconds since Unix epoch
+     */
+    setTxCreationTime(txCreationTime: 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, blockhash, or instructions are missing
+     *
+     * @example
+     * ```typescript
+     * const tx = builder.build();
+     * const signedTx = tx.sign(keypair);
+     * ```
+     */
+    build(): Transaction;
+}
+
+/**
+ * Converts bytes to base64 string.
+ *
+ * Works in both browser and Node.js environments.
+ */
+declare function toBase64(bytes: Uint8Array): string;
+/**
+ * Converts base64 string to bytes.
+ *
+ * Works in both browser and Node.js environments.
+ */
+declare function fromBase64(base64: string): Uint8Array;
+/**
+ * Sleeps for the specified duration.
+ *
+ * @param ms - Milliseconds to sleep
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Calculates exponential backoff delay with jitter.
+ *
+ * @param attempt - Current retry attempt (0-indexed)
+ * @param baseMs - Base delay in milliseconds
+ * @param maxMs - Maximum delay in milliseconds
+ * @returns Calculated delay with 30% random jitter
+ */
+declare function calculateBackoff(attempt: number, baseMs?: number, maxMs?: number): number;
+/**
+ * Returns the devnet RPC URL.
+ */
+declare function getDevnetUrl(): string;
+/**
+ * Returns the testnet RPC URL.
+ */
+declare function getTestnetUrl(): string;
+/**
+ * Returns the mainnet RPC URL.
+ */
+declare function getMainnetUrl(): string;
+/**
+ * Returns the localnet RPC URL.
+ */
+declare function getLocalnetUrl(): string;
+
+export { type AccountInfo, type AccountMeta, AccountMetaTable, BASE_DERIVATION_PATH, BLOCKHASH_LENGTH, BaseRpcClient, Blockhash, type CompiledInstruction, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, type EpochInfoResponse, type GetConnectedFullNodesResponse, type GetFeeForMessageResponse, type GetHealthResponse, type GetSignaturesForAddressConfig, type GetSignaturesForAddressResponse, type GetSubscriptionsResponse, type GetTransactionsConfig, type GetTransactionsResponse, type GetTriggeredTransactionsResponse, type GetValidatorHealthResponse, type GetWorkflowLineageRequest, type GetWorkflowLineageResponse, HttpTransport, type HttpTransportConfig, type Instruction, type IsBlockhashValidResponse, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, type MessageHeader, Mnemonic, type MnemonicStrength, type MultipleAccountsResponse, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, type RpcErrorDetails$1 as RpcErrorDetails, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, type SendTransactionOptions, Signature, type SignatureStatus, type Signer, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, type TransactionResponse, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_TESTNET, calculateBackoff, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, sleep, toBase64, transferInstruction };