@quantabit/qbit-chain-sdk 1.2.0

package/src/types.d.ts

@@ -0,0 +1,760 @@
+/**
+ * @quantabit/qbit-chain-sdk TypeScript Type Definitions
+ */
+
+import { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } from '@solana/web3.js';
+
+// ============ Constants ============
+
+export declare const LAMPORTS_PER_QBT: number;
+export declare const QBIT_COIN_TYPE: 766;
+
+export declare const GENESIS_HASH: {
+    mainnet: string;
+    devnet: string;
+};
+
+export declare const CHAIN_PARAMS: {
+    SLOT_DURATION_MS: number;
+    SLOTS_PER_EPOCH: number;
+    NATIVE_TOKEN_SYMBOL: string;
+    NATIVE_TOKEN_DECIMALS: number;
+};
+
+export declare const CHAIN_PROGRAMS: {
+    SYSTEM_PROGRAM: string;
+    TOKEN_PROGRAM: string;
+    ASSOCIATED_TOKEN_PROGRAM: string;
+    MEMO_PROGRAM: string;
+    STAKE_PROGRAM: string;
+    STAKE_CONFIG: string;
+    VOTE_PROGRAM: string;
+    DID_PROGRAM: string;
+};
+
+export interface ChainEndpoint {
+    rpc: string;
+    ws: string;
+    genesisHash: string | null;
+}
+
+export declare const CHAIN_ENDPOINTS: {
+    mainnet: ChainEndpoint;
+    testnet: ChainEndpoint;
+    devnet: ChainEndpoint;
+};
+
+export declare const DEFAULT_CONFIRM_OPTIONS: {
+    commitment: string;
+    preflightCommitment: string;
+    skipPreflight: boolean;
+};
+
+export declare const TIMEOUT: {
+    RPC_REQUEST: number;
+    SEND_TRANSACTION: number;
+    CONFIRM_TRANSACTION: number;
+    HEALTH_CHECK: number;
+};
+
+export declare const RETRY: {
+    MAX_RETRIES: number;
+    BASE_DELAY_MS: number;
+    MAX_DELAY_MS: number;
+};
+
+// ============ Connection ============
+
+export interface QBitConnectionOptions {
+    endpoint?: string;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    wsEndpoint?: string;
+    timeoutMs?: number;
+    network?: 'mainnet' | 'devnet' | 'testnet';
+    autoValidate?: boolean;
+    onConnect?: (info: { endpoint: string; network: string }) => void;
+    onDisconnect?: (info: { endpoint: string; error?: Error; reason?: string }) => void;
+    onError?: (error: Error) => void;
+    onNetworkMismatch?: (info: { expected: string; actual: string; network: string }) => void;
+}
+
+export interface NetworkValidationResult {
+    valid: boolean;
+    expected: string | null;
+    actual: string;
+    network: string;
+}
+
+export interface ConnectionInfo {
+    endpoint: string;
+    wsEndpoint: string | null;
+    network: string;
+    commitment: string;
+    isConnected: boolean;
+    lastHealthCheck: number | null;
+    timeoutMs: number;
+}
+
+export declare class QBitConnection {
+    constructor(options?: QBitConnectionOptions);
+    get raw(): Connection;
+    getRawConnection(): Promise<Connection>;
+    get endpoint(): string;
+    get network(): string;
+    get isConnected(): boolean;
+    switchNetwork(network: 'mainnet' | 'devnet' | 'testnet'): void;
+    validateNetwork(): Promise<NetworkValidationResult>;
+    getHealth(): Promise<string>;
+    getVersion(): Promise<Record<string, string | number>>;
+    getSlot(): Promise<number>;
+    getBlockHeight(): Promise<number>;
+    getEpochInfo(): Promise<{
+        absoluteSlot: number;
+        blockHeight: number;
+        epoch: number;
+        slotIndex: number;
+        slotsInEpoch: number;
+        transactionCount: number;
+    }>;
+    getLatestBlockhash(): Promise<{ blockhash: string; lastValidBlockHeight: number }>;
+    getGenesisHash(): Promise<string>;
+    getSupply(): Promise<any>;
+    getClusterNodes(): Promise<any[]>;
+    getVoteAccounts(): Promise<{ current: any[]; delinquent: any[] }>;
+    getTransactionCount(): Promise<number>;
+    getBlock(slot: number, options?: { transactionDetails?: 'full' | 'accounts' | 'signatures' | 'none'; rewards?: boolean; commitment?: string }): Promise<any | null>;
+    getBlockTime(slot: number): Promise<number | null>;
+    getBlocks(startSlot: number, endSlot?: number): Promise<number[]>;
+    getFirstAvailableBlock(): Promise<number>;
+    getRecentPerformanceSamples(limit?: number): Promise<any[]>;
+    getInflationRate(): Promise<{ total: number; validator: number; foundation: number; epoch: number }>;
+    getInflationReward(addresses: Array<string | PublicKey>, epoch?: number): Promise<any[]>;
+    requestAirdrop(address: string | PublicKey, amountQBT: number): Promise<string>;
+    getBalance(address: string | PublicKey): Promise<number>;
+    getBalanceQBT(address: string | PublicKey): Promise<number>;
+    getAccountInfo(address: string | PublicKey): Promise<any | null>;
+    accountExists(address: string | PublicKey): Promise<boolean>;
+    getMultipleBalances(addresses: string[]): Promise<Array<{ address: string; lamports: number; qbt: number }>>;
+    sendTransaction(transaction: Transaction, options?: { skipPreflight?: boolean; preflightCommitment?: string }): Promise<string>;
+    confirmTransaction(signature: string, commitment?: string, context?: any): Promise<any>;
+    getTransaction(signature: string): Promise<any | null>;
+    getSignaturesForAddress(address: string | PublicKey, options?: { limit?: number; before?: string; until?: string }): Promise<any[]>;
+    getMinimumBalanceForRentExemption(dataSize: number): Promise<number>;
+    getTokenAccountsByOwner(owner: string | PublicKey): Promise<any[]>;
+    getTokenBalance(tokenAccountAddress: string): Promise<{ amount: string; decimals: number; uiAmount: number }>;
+    getConnectionInfo(): ConnectionInfo;
+    destroy(): void;
+}
+
+export declare function getDefaultConnection(): QBitConnection;
+export declare function resetDefaultConnection(options?: QBitConnectionOptions): QBitConnection;
+export declare function resolveRawConnection(connection: QBitConnection | { raw: Connection; getRawConnection?: () => Promise<Connection> }): Promise<Connection>;
+export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, operationName?: string): Promise<T>;
+
+// ============ Keypair ============
+
+export interface KeypairGenerateOptions {
+    strength?: 128 | 256;
+    accountIndex?: number;
+    useLegacyPath?: boolean;
+    language?: string;
+}
+
+export interface KeypairFromMnemonicOptions {
+    accountIndex?: number;
+    coinType?: number;
+    useLegacyPath?: boolean;
+}
+
+export declare class QBitKeypair {
+    get publicKey(): PublicKey;
+    get address(): string;
+    get keypair(): Keypair;
+    get mnemonic(): string | null;
+    get derivationPath(): string;
+    exportPrivateKey(): string;
+    exportSecretKey(): Uint8Array;
+    sign(message: Uint8Array | string): Uint8Array;
+    signBase58(message: string): string;
+    destroy(): void;
+
+    static generate(options?: KeypairGenerateOptions): Promise<QBitKeypair>;
+    static fromMnemonic(mnemonic: string, options?: KeypairFromMnemonicOptions): Promise<QBitKeypair>;
+    static fromPrivateKey(privateKey: string | Uint8Array): QBitKeypair;
+    static fromJsonKey(jsonKey: number[]): QBitKeypair;
+    static random(): QBitKeypair;
+    static deriveMultiple(mnemonic: string, count: number, startIndex?: number, options?: { useLegacyPath?: boolean; coinType?: number }): Promise<QBitKeypair[]>;
+}
+
+export declare function generateMnemonic(strength?: number): string;
+export declare function mnemonicToKeypair(mnemonic: string, accountIndex?: number): Promise<QBitKeypair>;
+export declare function validateMnemonic(mnemonic: string): boolean;
+export declare function verifySignature(message: string, signature: Uint8Array | string, publicKey: string | PublicKey): boolean;
+
+// ============ Transaction ============
+
+export interface TransferResult {
+    signature: string;
+    amount: number;
+    from: string;
+    to: string;
+    memo?: string | null;
+}
+
+export interface TokenTransferResult {
+    signature: string;
+    mint: string;
+    amount: number;
+    from: string;
+    to: string;
+}
+
+export interface SimulationResult {
+    err: any | null;
+    logs: string[];
+    unitsConsumed: number;
+    estimatedFee: number;
+    returnData: any | null;
+}
+
+export declare class QBitTransaction {
+    constructor(connection?: QBitConnection);
+    addInstruction(instruction: TransactionInstruction): QBitTransaction;
+    addSigner(signer: Keypair | QBitKeypair): QBitTransaction;
+    transfer(from: PublicKey | string, to: PublicKey | string, amountQBT: number): QBitTransaction;
+    transferToken(from: PublicKey | string, to: PublicKey | string, mintAddress: string, amount: number, decimals: number, feePayer?: PublicKey | string): Promise<QBitTransaction>;
+    batchTransfer(from: PublicKey | string, transfers: Array<{ to: string; amountQBT: number }>): QBitTransaction;
+    addMemo(memo: string): QBitTransaction;
+    setComputeUnits(units: number): QBitTransaction;
+    setPriorityFee(microLamports: number): QBitTransaction;
+    build(feePayer: PublicKey | string): Promise<Transaction>;
+    signTransaction(signer: Keypair | QBitKeypair): Promise<Transaction>;
+    sendAndConfirm(signer: Keypair | QBitKeypair, options?: { skipPreflight?: boolean; commitment?: string; feePayer?: PublicKey | string }): Promise<string>;
+    send(signer: Keypair | QBitKeypair, options?: { skipPreflight?: boolean; commitment?: string; feePayer?: PublicKey | string }): Promise<string>;
+    confirm(signature: string, commitment?: string): Promise<any>;
+    simulate(signer: Keypair | QBitKeypair): Promise<SimulationResult>;
+}
+
+export declare function transferQBT(connection: QBitConnection, fromKeypair: Keypair | QBitKeypair, toAddress: string, amountQBT: number, options?: { memo?: string; skipPreflight?: boolean; commitment?: string }): Promise<TransferResult>;
+export declare function transferToken(connection: QBitConnection, fromKeypair: Keypair | QBitKeypair, toAddress: string, mintAddress: string, amount: number, decimals: number, options?: { memo?: string; skipPreflight?: boolean; commitment?: string }): Promise<TokenTransferResult>;
+export declare function estimateTransactionFee(connection: QBitConnection, transaction: Transaction): Promise<number>;
+
+// ============ SPL Token Lifecycle ============
+
+export interface TokenTxOptions {
+    skipPreflight?: boolean;
+    commitment?: string;
+}
+
+export interface CreateMintResult {
+    signature: string;
+    mint: string;
+    decimals: number;
+    mintAuthority: string;
+    freezeAuthority: string | null;
+}
+
+export interface CreateMintOptions extends TokenTxOptions {
+    decimals?: number;
+    mintAuthority?: PublicKey | string;
+    freezeAuthority?: PublicKey | string | null;
+    mintKeypair?: Keypair;
+}
+
+export type TokenAuthorityType = 'MintTokens' | 'FreezeAccount' | 'AccountOwner' | 'CloseAccount';
+
+export declare function createMint(connection: QBitConnection, payer: Keypair | QBitKeypair, options?: CreateMintOptions): Promise<CreateMintResult>;
+export declare function getOrCreateTokenAccount(connection: QBitConnection, payer: Keypair | QBitKeypair, mintAddress: string, ownerAddress?: string): Promise<{ address: string; created: boolean; signature: string | null }>;
+export declare function mintTo(connection: QBitConnection, mintAuthority: Keypair | QBitKeypair, mintAddress: string, toAddress: string, amount: number | bigint, options?: TokenTxOptions): Promise<{ signature: string; mint: string; to: string; tokenAccount: string; amount: string }>;
+export declare function burn(connection: QBitConnection, owner: Keypair | QBitKeypair, mintAddress: string, amount: number | bigint, options?: TokenTxOptions & { decimals?: number }): Promise<{ signature: string; mint: string; amount: string }>;
+export declare function approve(connection: QBitConnection, owner: Keypair | QBitKeypair, mintAddress: string, delegateAddress: string, amount: number | bigint, options?: TokenTxOptions): Promise<{ signature: string; delegate: string; amount: string }>;
+export declare function revoke(connection: QBitConnection, owner: Keypair | QBitKeypair, mintAddress: string, options?: TokenTxOptions): Promise<{ signature: string }>;
+export declare function freezeAccount(connection: QBitConnection, freezeAuthority: Keypair | QBitKeypair, mintAddress: string, ownerAddress: string, options?: TokenTxOptions): Promise<{ signature: string; tokenAccount: string }>;
+export declare function thawAccount(connection: QBitConnection, freezeAuthority: Keypair | QBitKeypair, mintAddress: string, ownerAddress: string, options?: TokenTxOptions): Promise<{ signature: string; tokenAccount: string }>;
+export declare function setAuthority(connection: QBitConnection, currentAuthority: Keypair | QBitKeypair, targetAddress: string, authorityType: TokenAuthorityType, newAuthorityAddress: string | null, options?: TokenTxOptions): Promise<{ signature: string; authorityType: string; newAuthority: string | null }>;
+export declare function closeTokenAccount(connection: QBitConnection, owner: Keypair | QBitKeypair, mintAddress: string, destinationAddress?: string, options?: TokenTxOptions): Promise<{ signature: string; tokenAccount: string }>;
+export declare function getTokenAccountDelegation(connection: QBitConnection, tokenAccountAddress: string): Promise<{ delegate: string | null; delegatedAmount: string }>;
+
+// ============ Anchor Memo ============
+
+export declare const QBIT_ANCHOR_NAMESPACE: 'qbit_anchor';
+export declare const QBIT_DID_ANCHOR_NAMESPACE: 'qbit_did';
+export declare const MAX_QBIT_ANCHOR_MEMO_BYTES: 512;
+
+export interface QBitAnchorMemoPayload {
+    action?: string;
+    subject?: string;
+    did?: string;
+    credential_id?: string;
+    resource_id?: string;
+    document_hash?: string;
+    credential_hash?: string;
+    content_hash?: string;
+    version?: string | number;
+    timestamp?: string | number;
+    extra?: Record<string, any>;
+}
+
+export interface QBitAnchorMemoOptions {
+    namespace?: string;
+    maxBytes?: number;
+    priorityFee?: number;
+}
+
+export interface QBitAnchorTransactionResult {
+    transaction: Transaction;
+    memo: string;
+    payload: Record<string, any> | null;
+}
+
+export declare function buildQBitAnchorMemo(payload: QBitAnchorMemoPayload, options?: QBitAnchorMemoOptions): string;
+export declare function parseQBitAnchorMemo(memo: string, options?: { namespace?: string }): Record<string, any> | null;
+export declare function extractQBitAnchorMemos(transaction: any, options?: { namespace?: string }): Array<Record<string, any>>;
+export declare function createQBitAnchorTransaction(
+    connection: QBitConnection,
+    feePayer: string | PublicKey,
+    payload: QBitAnchorMemoPayload,
+    options?: QBitAnchorMemoOptions
+): Promise<QBitAnchorTransactionResult>;
+
+export interface QBitAnchorWalletProvider {
+    publicKey?: { toBase58?: () => string; toString?: () => string };
+    signAndSendTransaction?: (transaction: Transaction, options?: any) => Promise<any>;
+    signTransaction?: (transaction: Transaction) => Promise<Transaction>;
+}
+
+export interface BroadcastAnchorOptions extends QBitAnchorMemoOptions {
+    address?: string;
+    skipPreflight?: boolean;
+    preflightCommitment?: string;
+    waitForConfirmation?: boolean;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    pollIntervalMs?: number;
+    maxPolls?: number;
+    timeoutMs?: number;
+}
+
+export interface BroadcastAnchorResult {
+    txHash: string | null;
+    memo: string;
+    raw: any;
+    confirmed?: boolean;
+    slot?: number | null;
+}
+
+export interface AnchorConfirmationResult {
+    confirmed: boolean;
+    slot: number | null;
+    status: string | null;
+    timedOut?: boolean;
+}
+
+export interface VerifyAnchoredMemoResult {
+    found: boolean;
+    matched: boolean;
+    memos: Array<Record<string, any>>;
+}
+
+export declare function broadcastQBitAnchor(
+    connection: QBitConnection,
+    provider: QBitAnchorWalletProvider,
+    memoOrPayload: QBitAnchorMemoPayload | string,
+    options?: BroadcastAnchorOptions
+): Promise<BroadcastAnchorResult>;
+
+export declare function waitForAnchorConfirmation(
+    connection: QBitConnection | { raw?: any; getRawConnection?: () => Promise<any> },
+    signature: string,
+    options?: { commitment?: string; pollIntervalMs?: number; maxPolls?: number; timeoutMs?: number }
+): Promise<AnchorConfirmationResult>;
+
+export declare function verifyAnchoredMemo(
+    connection: QBitConnection | { raw?: any; getRawConnection?: () => Promise<any> },
+    txHash: string,
+    options?: { namespace?: string; commitment?: string; match?: Record<string, any> }
+): Promise<VerifyAnchoredMemoResult>;
+
+// ============ Account ============
+
+export interface AccountInfo {
+    address: string;
+    lamports: number;
+    qbt: number;
+    owner: string;
+    executable: boolean;
+    rentEpoch: number;
+    dataSize: number;
+}
+
+export interface TokenAccount {
+    address: string;
+    mint: string;
+    owner: string;
+    amount: string;
+    decimals: number;
+    uiAmount: number;
+}
+
+export interface TokenMintInfo {
+    address: string;
+    supply: string;
+    decimals: number;
+    mintAuthority: string | null;
+    freezeAuthority: string | null;
+    isInitialized: boolean;
+}
+
+export interface TransactionHistoryItem {
+    signature: string;
+    slot: number;
+    blockTime: number | null;
+    confirmationStatus: string;
+    err: any | null;
+    memo: string | null;
+    fee?: number;
+    preBalances?: number[];
+    postBalances?: number[];
+    logMessages?: string[];
+}
+
+export declare function getAccountInfo(address: string, connection?: QBitConnection): Promise<AccountInfo | null>;
+export declare function getBalance(address: string, connection?: QBitConnection): Promise<{ lamports: number; qbt: number }>;
+export declare function getTokenAccounts(ownerAddress: string, connection?: QBitConnection): Promise<TokenAccount[]>;
+export declare function getTokenMintInfo(mintAddress: string, connection?: QBitConnection): Promise<TokenMintInfo>;
+export declare function getAssociatedTokenAccount(ownerAddress: string, mintAddress: string, connection?: QBitConnection): Promise<{ address: string; exists: boolean }>;
+export declare function getTransactionHistory(address: string, options?: { limit?: number; before?: string; until?: string; withDetails?: boolean }, connection?: QBitConnection): Promise<TransactionHistoryItem[]>;
+export declare function getStakeAccounts(ownerAddress: string, connection?: QBitConnection): Promise<any[]>;
+
+// ============ Stake ============
+
+export interface StakeResult {
+    signature: string;
+    stakeAccount: string;
+    amount: number;
+    validator: string;
+}
+
+export interface StakeActivation {
+    state: 'active' | 'inactive' | 'activating' | 'deactivating';
+    active: number;
+    inactive: number;
+}
+
+export interface ValidatorInfo {
+    votePubkey: string;
+    nodePubkey: string;
+    activatedStake: number;
+    activatedStakeQBT: number;
+    commission: number;
+    lastVote: number;
+    epochCredits?: any[];
+}
+
+export interface ValidatorsResult {
+    current: ValidatorInfo[];
+    delinquent: ValidatorInfo[];
+    totalValidators: number;
+    totalStake: number;
+}
+
+export declare function createStakeAccount(connection: QBitConnection, fromKeypair: Keypair | QBitKeypair, voteAccountAddress: string, amountQBT: number, options?: { stakeKeypair?: Keypair; staker?: string; withdrawer?: string }): Promise<StakeResult>;
+export declare function delegate(connection: QBitConnection, authorizedKeypair: Keypair | QBitKeypair, stakeAccountAddress: string, voteAccountAddress: string): Promise<string>;
+export declare function deactivate(connection: QBitConnection, authorizedKeypair: Keypair | QBitKeypair, stakeAccountAddress: string): Promise<string>;
+export declare function withdrawStake(connection: QBitConnection, withdrawerKeypair: Keypair | QBitKeypair, stakeAccountAddress: string, toAddress: string, amountQBT?: number): Promise<string>;
+export declare function getStakeActivation(connection: QBitConnection, stakeAccountAddress: string): Promise<StakeActivation>;
+export declare function getValidators(connection: QBitConnection): Promise<ValidatorsResult>;
+
+// ============ RPC ============
+
+export interface ChainStatus {
+    health: string;
+    network: string;
+    endpoint: string;
+    version: string;
+    featureSet: number;
+    epoch: number;
+    blockHeight: number;
+    slot: number;
+    slotProgress: string;
+    totalSupplyQBT: number;
+    circulatingQBT: number;
+    transactionCount: number;
+}
+
+export declare function getChainHealth(connection?: QBitConnection): Promise<string>;
+export declare function getChainVersion(connection?: QBitConnection): Promise<Record<string, string | number>>;
+export declare function getBlockHeight(connection?: QBitConnection): Promise<number>;
+export declare function getSlot(connection?: QBitConnection): Promise<number>;
+export declare function getEpochInfo(connection?: QBitConnection): Promise<any>;
+export declare function getLatestBlockhash(connection?: QBitConnection): Promise<{ blockhash: string; lastValidBlockHeight: number }>;
+export declare function getGenesisHash(connection?: QBitConnection): Promise<string>;
+export declare function getSupply(connection?: QBitConnection): Promise<any>;
+export declare function getMinimumBalanceForRentExemption(dataSize?: number, connection?: QBitConnection): Promise<number>;
+export declare function getClusterNodes(connection?: QBitConnection): Promise<any[]>;
+export declare function getVoteAccounts(connection?: QBitConnection): Promise<any>;
+export declare function getTransactionCount(connection?: QBitConnection): Promise<number>;
+export declare function getBlock(slot: number, options?: { transactionDetails?: string; rewards?: boolean; commitment?: string }, connection?: QBitConnection): Promise<any | null>;
+export declare function getBlockTime(slot: number, connection?: QBitConnection): Promise<number | null>;
+export declare function getBlocks(startSlot: number, endSlot?: number, connection?: QBitConnection): Promise<number[]>;
+export declare function getRecentPerformanceSamples(limit?: number, connection?: QBitConnection): Promise<any[]>;
+export declare function getInflationRate(connection?: QBitConnection): Promise<{ total: number; validator: number; foundation: number; epoch: number }>;
+export declare function requestAirdrop(address: string, amountQBT: number, connection?: QBitConnection): Promise<string>;
+export declare function validateNetwork(connection?: QBitConnection): Promise<NetworkValidationResult>;
+export declare function getChainStatus(connection?: QBitConnection): Promise<ChainStatus>;
+
+// ============ Utils ============
+
+export declare function qbtToLamports(qbt: number): number;
+export declare function lamportsToQbt(lamports: number): number;
+export declare function formatQbt(lamports: number, decimals?: number): string;
+export declare function isValidAddress(address: string): boolean;
+export declare function shortenAddress(address: string, startLen?: number, endLen?: number): string;
+export declare function toPublicKey(addressOrKey: string | PublicKey): PublicKey;
+
+// ============ Errors ============
+
+export declare class QBitError extends Error {
+    code: string;
+    details: Record<string, any>;
+    timestamp: number;
+    constructor(message: string, code?: string, details?: Record<string, any>);
+    toJSON(): { name: string; code: string; message: string; details: Record<string, any>; timestamp: number };
+}
+
+export declare class QBitRpcError extends QBitError {
+    rpcCode: number;
+    method: string;
+    constructor(message: string, rpcCode?: number, method?: string);
+}
+
+export declare class QBitNetworkError extends QBitError {
+    endpoint: string;
+    cause: Error | null;
+    constructor(message: string, endpoint?: string, cause?: Error | null);
+}
+
+export declare class QBitNetworkMismatchError extends QBitError {
+    constructor(expected: string, actual: string, network: string);
+}
+
+export declare class QBitTransactionError extends QBitError {
+    signature: string;
+    logs: string[];
+    constructor(message: string, signature?: string, logs?: string[]);
+}
+
+export declare class QBitInsufficientFundsError extends QBitTransactionError {
+    constructor(required: number, available: number);
+}
+
+export declare class QBitAccountNotFoundError extends QBitError {
+    constructor(address: string);
+}
+
+export declare class QBitTokenError extends QBitError {
+    constructor(message: string, mintAddress?: string, details?: Record<string, any>);
+}
+
+export declare class QBitKeypairError extends QBitError {
+    constructor(message: string);
+}
+
+export declare const ERROR_CODES: {
+    NETWORK_ERROR: string;
+    NETWORK_MISMATCH: string;
+    RPC_ERROR: string;
+    TIMEOUT: string;
+    TRANSACTION_ERROR: string;
+    INSUFFICIENT_FUNDS: string;
+    SIGNATURE_FAILED: string;
+    BLOCKHASH_EXPIRED: string;
+    ACCOUNT_NOT_FOUND: string;
+    TOKEN_ERROR: string;
+    ATA_NOT_FOUND: string;
+    KEYPAIR_ERROR: string;
+    INVALID_MNEMONIC: string;
+    INVALID_PRIVATE_KEY: string;
+};
+
+// ============ Subscription ============
+
+export interface AccountChangeInfo {
+    address: string;
+    lamports: number;
+    owner: string;
+    dataSize: number;
+    executable: boolean;
+    rentEpoch: number;
+    slot: number;
+}
+
+export interface ProgramLogsInfo {
+    programId: string;
+    signature: string;
+    err: any | null;
+    logs: string[];
+    slot: number;
+}
+
+export interface SlotChangeInfo {
+    slot: number;
+    parent: number;
+    root: number;
+}
+
+export interface SignatureInfo {
+    signature: string;
+    err: any | null;
+    confirmed: boolean;
+    slot: number;
+}
+
+export declare class QBitSubscription {
+    constructor(connection: QBitConnection);
+    onAccountChange(address: string, callback: (info: AccountChangeInfo, context: any) => void, commitment?: string): number;
+    onProgramLogs(programId: string, callback: (info: ProgramLogsInfo, context: any) => void, commitment?: string): number;
+    onAllLogs(callback: (info: Omit<ProgramLogsInfo, 'programId'>, context: any) => void, commitment?: string): number;
+    onSlotChange(callback: (info: SlotChangeInfo) => void): number;
+    onSignature(signature: string, callback: (info: SignatureInfo, context: any) => void, commitment?: string): number;
+    onRootChange(callback: (info: { root: number }) => void): number;
+    unsubscribe(subscriptionId: number): boolean;
+    unsubscribeAll(): void;
+    getActiveSubscriptions(): Array<{ id: number; type: string; target?: string }>;
+    get activeCount(): number;
+    destroy(): void;
+}
+
+// ============ Token Registry ============
+
+export interface TokenMeta {
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    icon: string;
+    category: 'native' | 'stablecoin' | 'governance' | 'utility' | 'lp';
+    verified: boolean;
+    mintAuthority?: string | null;
+    freezeAuthority?: string | null;
+    supply?: string;
+}
+
+export declare class TokenRegistry {
+    constructor(connection?: QBitConnection | null);
+    getToken(mintAddress: string): TokenMeta | null;
+    resolveToken(mintAddress: string): Promise<TokenMeta | null>;
+    resolveMany(mintAddresses: string[]): Promise<Map<string, TokenMeta>>;
+    register(tokenMeta: Partial<TokenMeta> & { address: string }): void;
+    registerMany(tokens: Array<Partial<TokenMeta> & { address: string }>): void;
+    getAll(category?: string | null): TokenMeta[];
+    getVerified(): TokenMeta[];
+    search(query: string): TokenMeta[];
+    formatAmount(mintAddress: string, rawAmount: number | string, displayDecimals?: number): string;
+    formatWithSymbol(mintAddress: string, rawAmount: number | string): string;
+    get size(): number;
+}
+
+export declare function getTokenRegistry(connection?: QBitConnection | null): TokenRegistry;
+export declare const KNOWN_TOKENS: Readonly<Record<string, TokenMeta>>;
+
+// ============ Transaction Parser ============
+
+export interface ParsedEvent {
+    type: string;
+    program: string;
+    from?: string;
+    to?: string;
+    amount?: number;
+    amountQBT?: number;
+    mint?: string;
+    decimals?: number;
+    stakeAccount?: string;
+    voteAccount?: string;
+    authority?: string;
+    newAccount?: string;
+    lamports?: number;
+    space?: number;
+    owner?: string;
+    inner?: boolean;
+    info?: Record<string, any>;
+}
+
+export interface ParsedProgram {
+    address: string;
+    name: string;
+}
+
+export interface ParsedTransaction {
+    signature: string;
+    type: string;
+    summary: string;
+    success: boolean;
+    fee: number;
+    feeQBT: number;
+    blockTime: number | null;
+    slot: number;
+    events: ParsedEvent[];
+    signers: string[];
+    programs: ParsedProgram[];
+    logs: string[];
+    raw: any | null;
+}
+
+export declare class TransactionParser {
+    constructor(connection: QBitConnection);
+    parse(signature: string): Promise<ParsedTransaction>;
+    parseMany(signatures: string[]): Promise<ParsedTransaction[]>;
+    parseRecentForAddress(address: string, limit?: number): Promise<ParsedTransaction[]>;
+}
+
+// ============ Program Helper ============
+
+export interface ProgramAccountInfo {
+    pubkey: string;
+    lamports: number;
+    dataSize: number;
+    data: Buffer;
+    owner: string;
+}
+
+export interface PDAAccountInfo {
+    address: string;
+    exists: boolean;
+    data: Buffer | null;
+    lamports: number;
+}
+
+export interface ProgramAccountFilters {
+    dataSize?: number;
+    memcmp?: Array<{ offset: number; bytes: string }>;
+}
+
+export declare class ProgramHelper {
+    constructor(connection: QBitConnection, programId: string | PublicKey);
+    get programId(): PublicKey;
+
+    // PDA
+    findPDA(seeds: Array<Buffer | Uint8Array | string | PublicKey>): [PublicKey, number];
+    findPDAMany(seedsList: Array<Array<Buffer | Uint8Array | string | PublicKey>>): Array<[PublicKey, number]>;
+    isPDA(address: string | PublicKey): boolean;
+
+    // Instruction Building
+    buildInstruction(data: Buffer | Uint8Array, keys: Array<{ pubkey: PublicKey | string; isSigner: boolean; isWritable: boolean }>): TransactionInstruction;
+    buildIndexedInstruction(instructionIndex: number, payload: Buffer | null, keys: Array<{ pubkey: PublicKey | string; isSigner: boolean; isWritable: boolean }>): TransactionInstruction;
+
+    // Execution
+    execute(signer: Keypair, instructions: TransactionInstruction[], options?: { skipPreflight?: boolean; commitment?: string }): Promise<string>;
+    simulate(signer: Keypair, instructions: TransactionInstruction[]): Promise<{ err: any; logs: string[]; unitsConsumed: number }>;
+
+    // Account Queries
+    getAccounts(filters?: ProgramAccountFilters): Promise<ProgramAccountInfo[]>;
+    getPDAAccount(seeds: Array<Buffer | Uint8Array | string>): Promise<PDAAccountInfo>;
+
+    // Serialization Helpers
+    static encodeU32(value: number): Buffer;
+    static encodeU64(value: bigint | number): Buffer;
+    static encodeString(str: string): Buffer;
+    static decodeU32(buf: Buffer, offset?: number): number;
+    static decodeU64(buf: Buffer, offset?: number): bigint;
+    static decodeString(buf: Buffer, offset?: number): { value: string; bytesRead: number };
+}