import { bn as Script, t as ConnectPeerParams, v as DisconnectPeerParams, a4 as ListPeersResult, aa as OpenChannelParams, ab as OpenChannelResult, ac as OpenChannelWithExternalFundingParams, ad as OpenChannelWithExternalFundingResult, aH as SubmitSignedFundingTxParams, aI as SubmitSignedFundingTxResult, b as AcceptChannelParams, c as AcceptChannelResult, a0 as ListChannelsParams, a1 as ListChannelsResult, aG as ShutdownChannelParams, a as AbandonChannelParams, aT as UpdateChannelParams, ay as SendPaymentParams, az as SendPaymentResult, z as GetPaymentParams, H as GetPaymentResult, a2 as ListPaymentsParams, a3 as ListPaymentsResult, B as BuildRouterParams, e as BuildRouterResult, aA as SendPaymentWithRouterParams, a6 as NewInvoiceParams, a7 as NewInvoiceResult, af as ParseInvoiceParams, ag as ParseInvoiceResult, G as GetInvoiceParams, y as GetInvoiceResult, f as CancelInvoiceParams, g as CancelInvoiceResult, aD as SettleInvoiceParams, a9 as NodeInfoResult, M as GraphNodesParams, N as GraphNodesResult, J as GraphChannelsParams, K as GraphChannelsResult, U as IFiberClient, ai as PaymentHash, m as ChannelId, l as Channel, r as CkbInvoiceStatus, j as CellDep, Q as HexString, O as Hash256 } from '../resolve-B7MJYzSy.js';
export { F as BrowserRpcClient, bo as BrowserRpcClientConfig, n as ChannelState, s as CkbTransaction, D as DEFAULT_CKB_ASSET, F as FiberRpcClient, w as FiberRpcError, x as FormattedChannelBalances, a5 as Multiaddr, al as PeerId, ao as Pubkey, aq as ResolveUdtAssetOptions, bo as RpcClientConfig, aL as TransportType, aN as UdtAsset, aS as UdtTypeScript, aU as areUdtTypeScriptsEqual, aV as buildMultiaddr, aW as buildMultiaddrFromNodeId, aY as ckbHash, aZ as ckbToShannons, a$ as derivePublicKey, b1 as formatAssetName, b2 as formatChannelBalances, b3 as fromHex, b8 as nodeIdToPeerId, b9 as normalizeChannel, ba as normalizeChannelStateName, bb as parseFundingAmount, bc as parsePaymentAmount, bd as parseUdtTypeScript, bf as resolveUdtAsset, bg as scriptToAddress, bh as serializeUdtTypeScript, bj as shannonsToCkb, bk as toHex, bl as validateUdtTypeScript } from '../resolve-B7MJYzSy.js';

/**
 * ConfigBuilder — Generates YAML config strings for Fiber WASM nodes
 *
 * Encapsulates the complex YAML configuration that @nervosnetwork/fiber-js
 * requires, providing a TypeScript-friendly API with sensible defaults
 * for testnet and mainnet.
 */

interface UdtWhitelistEntry {
    name: string;
    script: Script;
    cellDeps: Array<{
        typeId?: Script;
        cellDep?: {
            outPoint: {
                txHash: string;
                index: string;
            };
            depType: 'code' | 'dep_group';
        };
    }>;
    autoAcceptAmount?: string;
}
interface BrowserNodeConfig {
    /** Network to connect to */
    network: 'testnet' | 'mainnet';
    /** Custom bootnode addresses (optional, defaults to built-in list) */
    bootnodes?: string[];
    /** CKB RPC URL (optional, defaults to public endpoint) */
    ckbRpcUrl?: string;
    /** UDT whitelist entries */
    udtWhitelist?: UdtWhitelistEntry[];
    /** Log level for WASM node */
    logLevel?: 'trace' | 'debug' | 'info' | 'error';
    /** IndexedDB storage prefix (defaults to credential identifier) */
    databasePrefix?: string;
    /** Whether to announce the listening address (usually false for browser) */
    announceListeningAddr?: boolean;
    /** Custom P2P listening address (optional, defaults to /ip4/127.0.0.1/tcp/8228) */
    p2pListeningAddr?: string;
    /** Custom RPC listening address (optional, defaults to 127.0.0.1:8227) */
    rpcListeningAddr?: string;
}
declare class ConfigBuilder {
    /**
     * Build a complete YAML config string for Fiber WASM node.
     *
     * @example
     * ```ts
     * const yaml = ConfigBuilder.build({ network: 'testnet' });
     * ```
     */
    static build(config: BrowserNodeConfig): string;
    /**
     * Get the default config for a network (useful for inspection/debugging).
     */
    static getDefaults(network: 'testnet' | 'mainnet'): {
        bootnodes: string[];
        ckbRpcUrl: string;
        scripts: readonly [{
            readonly name: "FundingLock";
            readonly script: {
                readonly code_hash: "0x6c67887fe201ee0c7853f1682c0b77c0e6214044c156c7558269390a8afa6d7c";
                readonly hash_type: "type";
                readonly args: "0x";
            };
            readonly cell_deps: readonly [{
                readonly type_id: {
                    readonly code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944";
                    readonly hash_type: "type";
                    readonly args: "0x3cb7c0304fe53f75bb5727e2484d0beae4bd99d979813c6fc97c3cca569f10f6";
                };
            }, {
                readonly cell_dep: {
                    readonly out_point: {
                        readonly tx_hash: "0x5a5288769cecde6451cb5d301416c297a6da43dc3ac2f3253542b4082478b19b";
                        readonly index: "0x0";
                    };
                    readonly dep_type: "code";
                };
            }];
        }, {
            readonly name: "CommitmentLock";
            readonly script: {
                readonly code_hash: "0x740dee83f87c6f309824d8fd3fbdd3c8380ee6fc9acc90b1a748438afcdf81d8";
                readonly hash_type: "type";
                readonly args: "0x";
            };
            readonly cell_deps: readonly [{
                readonly type_id: {
                    readonly code_hash: "0x00000000000000000000000000000000000000000000000000545950455f4944";
                    readonly hash_type: "type";
                    readonly args: "0xf7e458887495cf70dd30d1543cad47dc1dfe9d874177bf19291e4db478d5751b";
                };
            }, {
                readonly cell_dep: {
                    readonly out_point: {
                        readonly tx_hash: "0x5a5288769cecde6451cb5d301416c297a6da43dc3ac2f3253542b4082478b19b";
                        readonly index: "0x0";
                    };
                    readonly dep_type: "code";
                };
            }];
        }];
    };
    private static serializeUdtEntry;
}

/**
 * CredentialProvider — Decoupled key management interface for Fiber WASM nodes
 *
 * Design principles:
 * 1. Key *acquisition* and *usage* are separated
 * 2. Supports automation — once unlocked, subsequent operations don't require user interaction
 * 3. Extensible for future credential backends (e.g. WebAuthn Passkeys)
 *
 * The Fiber WASM node receives keys once at start() and handles all channel/PTLC signing
 * internally. Users only need to interact during the unlock() phase.
 */
/**
 * Abstract credential provider for Fiber WASM node key management.
 *
 * Implementations control how keys are derived, stored, and accessed.
 * The provider must be unlocked before keys can be retrieved.
 */
interface CredentialProvider {
    /**
     * Get the Fiber node key pair (used for P2P identity).
     * Must be 32 bytes.
     * @throws if provider is not unlocked
     */
    getFiberKeyPair(): Promise<Uint8Array>;
    /**
     * Get the CKB secret key (used for on-chain signing).
     * Must be 32 bytes. Returns undefined if using external funding mode.
     * @throws if provider is not unlocked
     */
    getCkbSecretKey(): Promise<Uint8Array | undefined>;
    /**
     * Unlock the credential provider — this is where user interaction happens.
     *
     * For password-based providers, the password is supplied here.
     * For passkey providers, this would trigger WebAuthn ceremony.
     * After unlock(), all subsequent key retrievals are automatic.
     *
     * @param params - Implementation-specific unlock parameters
     */
    unlock(params?: unknown): Promise<void>;
    /**
     * Lock the credential provider — wipe keys from memory.
     * After lock(), getFiberKeyPair() and getCkbSecretKey() will throw.
     */
    lock(): Promise<void>;
    /**
     * Whether the provider is currently unlocked.
     */
    isUnlocked(): boolean;
    /**
     * Unique identifier for this credential.
     * Used for IndexedDB prefix isolation so multiple identities
     * can coexist in the same browser.
     */
    getIdentifier(): string;
}
/**
 * Unlock parameters for PasswordCredentialProvider
 */
interface PasswordUnlockParams {
    /** Password used to derive keys via scrypt */
    password: string;
}
/**
 * Unlock parameters for RawKeyCredentialProvider (no-op, always unlocked)
 */
type RawKeyUnlockParams = undefined;

/**
 * FiberWasmAdapter — Adapter layer wrapping @nervosnetwork/fiber-js
 *
 * Maps the upstream Fiber WASM API to fiber-pay SDK types, providing:
 * - Strongly-typed RPC methods using existing SDK type definitions
 * - Node lifecycle management (start/stop/state)
 * - Error normalization to FiberRpcError
 * - Event emission for state changes
 *
 * This adapter isolates upstream API changes — if fiber-js API evolves,
 * only this file needs updating.
 */

/**
 * Upstream Fiber WASM instance interface.
 * Matches the API surface of @nervosnetwork/fiber-js Fiber class.
 * We define this interface rather than importing the class directly
 * to keep @nervosnetwork/fiber-js as an optional dependency.
 */
interface FiberWasmInstance {
    start(config: string, fiberKeyPair: Uint8Array, ckbSecretKey?: Uint8Array, chainSpec?: string, logLevel?: 'trace' | 'debug' | 'info' | 'error', databasePrefix?: string): Promise<void>;
    stop(): Promise<void>;
    invokeCommand(name: string, args?: unknown[]): Promise<unknown>;
}
/**
 * Factory function type for creating Fiber WASM instances.
 * This indirection allows users to provide their own Fiber constructor.
 */
type FiberWasmFactory = () => FiberWasmInstance;
type WasmAdapterState = 'stopped' | 'starting' | 'running' | 'stopping' | 'error';
interface WasmAdapterEvents {
    stateChange: (state: WasmAdapterState) => void;
    error: (error: Error) => void;
}
interface WasmAdapterConfig {
    /** Factory to create Fiber WASM instance */
    factory: FiberWasmFactory;
}
declare class FiberWasmAdapter {
    private instance;
    private _state;
    private factory;
    private listeners;
    constructor(config: WasmAdapterConfig);
    get state(): WasmAdapterState;
    /**
     * Start the WASM Fiber node.
     */
    start(params: {
        config: string;
        fiberKeyPair: Uint8Array;
        ckbSecretKey?: Uint8Array;
        chainSpec?: string;
        logLevel?: 'trace' | 'debug' | 'info' | 'error';
        databasePrefix?: string;
    }): Promise<void>;
    /**
     * Stop the WASM Fiber node.
     */
    stop(): Promise<void>;
    /**
     * Invoke a raw RPC command on the WASM node.
     * Prefer the typed methods below for standard operations.
     */
    invoke<T = unknown>(method: string, params?: unknown[]): Promise<T>;
    connectPeer(params: ConnectPeerParams): Promise<void>;
    disconnectPeer(params: DisconnectPeerParams): Promise<void>;
    listPeers(): Promise<ListPeersResult>;
    openChannel(params: OpenChannelParams): Promise<OpenChannelResult>;
    openChannelWithExternalFunding(params: OpenChannelWithExternalFundingParams): Promise<OpenChannelWithExternalFundingResult>;
    submitSignedFundingTx(params: SubmitSignedFundingTxParams): Promise<SubmitSignedFundingTxResult>;
    acceptChannel(params: AcceptChannelParams): Promise<AcceptChannelResult>;
    listChannels(params?: ListChannelsParams): Promise<ListChannelsResult>;
    shutdownChannel(params: ShutdownChannelParams): Promise<void>;
    abandonChannel(params: AbandonChannelParams): Promise<void>;
    updateChannel(params: UpdateChannelParams): Promise<void>;
    sendPayment(params: SendPaymentParams): Promise<SendPaymentResult>;
    getPayment(params: GetPaymentParams): Promise<GetPaymentResult>;
    listPayments(params?: ListPaymentsParams): Promise<ListPaymentsResult>;
    buildRouter(params: BuildRouterParams): Promise<BuildRouterResult>;
    sendPaymentWithRouter(params: SendPaymentWithRouterParams): Promise<SendPaymentResult>;
    newInvoice(params: NewInvoiceParams): Promise<NewInvoiceResult>;
    parseInvoice(params: ParseInvoiceParams): Promise<ParseInvoiceResult>;
    getInvoice(params: GetInvoiceParams): Promise<GetInvoiceResult>;
    cancelInvoice(params: CancelInvoiceParams): Promise<CancelInvoiceResult>;
    settleInvoice(params: SettleInvoiceParams): Promise<void>;
    nodeInfo(): Promise<NodeInfoResult>;
    graphNodes(params?: GraphNodesParams): Promise<GraphNodesResult>;
    graphChannels(params?: GraphChannelsParams): Promise<GraphChannelsResult>;
    on<K extends keyof WasmAdapterEvents>(event: K, listener: WasmAdapterEvents[K]): this;
    off<K extends keyof WasmAdapterEvents>(event: K, listener: WasmAdapterEvents[K]): this;
    private emit;
    private setState;
}

/**
 * FiberBrowserNode — High-level API for running a Fiber node in the browser
 *
 * This is the primary entry point for frontend developers. It orchestrates:
 * - Credential management (unlock → derive keys)
 * - Config generation (network defaults → YAML)
 * - WASM node lifecycle (init → start → stop)
 * - All RPC operations (payments, channels, invoices, etc.)
 *
 * @example
 * ```ts
 * import { FiberBrowserNode, PasswordCredentialProvider } from '@fiber-pay/sdk/browser';
 *
 * const node = new FiberBrowserNode({
 *   network: 'testnet',
 *   credential: new PasswordCredentialProvider('my-wallet'),
 * });
 *
 * await node.start({ password: 'user-secret' });
 * const info = await node.getNodeInfo();
 * console.log('Node pubkey:', info.pubkey);
 *
 * await node.sendPayment({ invoice: 'fibt1...' });
 * await node.stop();
 * ```
 */

type BrowserNodeState = 'idle' | 'unlocking' | 'starting' | 'running' | 'stopping' | 'stopped' | 'error';
interface FiberBrowserNodeConfig {
    /** Network configuration */
    network: 'testnet' | 'mainnet';
    /** Credential provider for key management */
    credential: CredentialProvider;
    /**
     * Factory to create Fiber WASM instance.
     * If not provided, will attempt to import @nervosnetwork/fiber-js dynamically.
     */
    wasmFactory?: FiberWasmFactory;
    /** Additional network config overrides */
    nodeConfig?: Partial<Omit<BrowserNodeConfig, 'network'>>;
}
interface StartOptions {
    /** Password for PasswordCredentialProvider (ignored for other providers) */
    password?: string;
    /** Any additional unlock params for custom credential providers */
    unlockParams?: unknown;
}
interface BrowserNodeEvents {
    stateChange: (state: BrowserNodeState) => void;
    error: (error: Error) => void;
}
declare class FiberBrowserNode implements IFiberClient {
    private config;
    private adapter;
    private _state;
    private listeners;
    constructor(config: FiberBrowserNodeConfig);
    /** Current node state */
    get state(): BrowserNodeState;
    /** Whether the node is currently running and ready for RPC calls */
    get isRunning(): boolean;
    /**
     * Start the browser Fiber node.
     *
     * This orchestrates the full startup sequence:
     * 1. Unlock credential provider (may require user input, e.g. password)
     * 2. Generate WASM config YAML from network defaults
     * 3. Initialize and start the WASM node
     *
     * After start(), all RPC methods are available and signing is automatic.
     */
    start(options?: StartOptions): Promise<NodeInfoResult>;
    /**
     * Stop the browser Fiber node.
     * Locks the credential provider to wipe keys from memory.
     */
    stop(): Promise<void>;
    private ensureRunning;
    nodeInfo(): Promise<NodeInfoResult>;
    /**
     * @deprecated Use `nodeInfo()` instead for consistency with FiberRpcClient.
     */
    getNodeInfo(): Promise<NodeInfoResult>;
    connectPeer(params: ConnectPeerParams): Promise<void>;
    disconnectPeer(params: DisconnectPeerParams): Promise<void>;
    listPeers(): Promise<ListPeersResult>;
    openChannel(params: OpenChannelParams): Promise<OpenChannelResult>;
    openChannelWithExternalFunding(params: OpenChannelWithExternalFundingParams): Promise<OpenChannelWithExternalFundingResult>;
    submitSignedFundingTx(params: SubmitSignedFundingTxParams): Promise<SubmitSignedFundingTxResult>;
    acceptChannel(params: AcceptChannelParams): Promise<AcceptChannelResult>;
    listChannels(params?: ListChannelsParams): Promise<ListChannelsResult>;
    shutdownChannel(params: ShutdownChannelParams): Promise<void>;
    abandonChannel(params: AbandonChannelParams): Promise<void>;
    updateChannel(params: UpdateChannelParams): Promise<void>;
    sendPayment(params: SendPaymentParams): Promise<SendPaymentResult>;
    getPayment(params: GetPaymentParams): Promise<GetPaymentResult>;
    listPayments(params?: ListPaymentsParams): Promise<ListPaymentsResult>;
    buildRouter(params: BuildRouterParams): Promise<BuildRouterResult>;
    sendPaymentWithRouter(params: SendPaymentWithRouterParams): Promise<SendPaymentResult>;
    newInvoice(params: NewInvoiceParams): Promise<NewInvoiceResult>;
    parseInvoice(params: ParseInvoiceParams): Promise<ParseInvoiceResult>;
    getInvoice(params: GetInvoiceParams): Promise<GetInvoiceResult>;
    cancelInvoice(params: CancelInvoiceParams): Promise<CancelInvoiceResult>;
    settleInvoice(params: SettleInvoiceParams): Promise<void>;
    graphNodes(params?: GraphNodesParams): Promise<GraphNodesResult>;
    graphChannels(params?: GraphChannelsParams): Promise<GraphChannelsResult>;
    /**
     * Wait for a payment to reach a terminal state (Success or Failed).
     */
    waitForPayment(paymentHash: PaymentHash, options?: {
        timeout?: number;
        interval?: number;
    }): Promise<GetPaymentResult>;
    /**
     * Wait for a channel to reach ChannelReady state.
     */
    waitForChannelReady(channelId: ChannelId, options?: {
        timeout?: number;
        interval?: number;
    }): Promise<Channel>;
    /**
     * Wait for an invoice to reach a specific status.
     */
    waitForInvoiceStatus(paymentHash: PaymentHash, targetStatus: CkbInvoiceStatus | CkbInvoiceStatus[], options?: {
        timeout?: number;
        interval?: number;
    }): Promise<GetInvoiceResult>;
    on<K extends keyof BrowserNodeEvents>(event: K, listener: BrowserNodeEvents[K]): this;
    off<K extends keyof BrowserNodeEvents>(event: K, listener: BrowserNodeEvents[K]): this;
    private emit;
    private setState;
    /**
     * Attempt to dynamically import @nervosnetwork/fiber-js.
     * This allows the package to remain an optional peer dependency.
     */
    private loadDefaultFactory;
}

type PasskeySupportReason = 'supported' | 'window-unavailable' | 'insecure-context' | 'webauthn-unavailable' | 'prf-unsupported' | 'unknown';
interface PasskeySupportStatus {
    supported: boolean;
    reason: PasskeySupportReason;
    isSecureContext: boolean;
    hasPublicKeyCredential: boolean;
    hasPlatformAuthenticator: boolean | null;
    prfCapable: boolean | null;
}
declare class PasskeyCredentialProvider implements CredentialProvider {
    private identifier;
    private fiberKey;
    private ckbKey;
    private skipCkbKey;
    constructor(identifier: string, options?: {
        skipCkbKey?: boolean;
    });
    /**
     * Check if the current browser environment supports Passkeys with the PRF extension.
     */
    static getSupportStatus(): Promise<PasskeySupportStatus>;
    /**
     * Check if passkey is supported or potentially supported (unknown capability).
     * Returns true when explicitly supported OR when capability is unknown,
     * allowing users to attempt passkey on platforms with incomplete capability reporting.
     */
    static isSupported(): Promise<boolean>;
    getIdentifier(): string;
    isUnlocked(): boolean;
    unlock(): Promise<void>;
    lock(): Promise<void>;
    getFiberKeyPair(): Promise<Uint8Array>;
    getCkbSecretKey(): Promise<Uint8Array | undefined>;
    /**
     * Registers a new Passkey and initializes the PRF extension secret.
     * Derives keys automatically and leaves the provider unlocked.
     */
    register(username?: string): Promise<void>;
    /**
     * Clears the passkey connection info for this identifier.
     */
    discard(): Promise<void>;
    /**
     * Has a passkey been registered for this identifier to attempt unlocking?
     */
    isConfigured(): boolean;
    /**
     * Use HKDF to expand the 32-byte PRF secret into 64 bytes (32 for Fiber, 32 for CKB).
     */
    private deriveKeysFromPrf;
}

/**
 * PasswordCredentialProvider
 *
 * Derives Fiber and CKB keys from a user-supplied password using scrypt.
 * Once unlocked, keys are cached in memory for the session — no per-operation
 * user interaction is required.
 *
 * Key derivation scheme:
 *   password + salt → scrypt → 64 bytes
 *     [0..32]  = Fiber key pair (P2P identity)
 *     [32..64] = CKB secret key (on-chain signing)
 *
 * The salt is persisted to IndexedDB so the same password always produces
 * the same keys on the same device. A new salt is generated on first use.
 */

declare class PasswordCredentialProvider implements CredentialProvider {
    private fiberKey;
    private ckbKey;
    private identifier;
    private skipCkbKey;
    /**
     * @param identifier - Unique identity string (e.g. user email or wallet name).
     *   Used for IndexedDB salt isolation and WASM database prefix.
     * @param options.skipCkbKey - If true, getCkbSecretKey() returns undefined.
     *   Useful for external funding mode where CKB signing is handled externally.
     */
    constructor(identifier: string, options?: {
        skipCkbKey?: boolean;
    });
    getFiberKeyPair(): Promise<Uint8Array>;
    getCkbSecretKey(): Promise<Uint8Array | undefined>;
    unlock(params?: PasswordUnlockParams): Promise<void>;
    lock(): Promise<void>;
    isUnlocked(): boolean;
    getIdentifier(): string;
}

/**
 * RawKeyCredentialProvider
 *
 * Directly holds raw 32-byte keys. Always "unlocked" after construction.
 * Primarily for development, testing, and advanced use cases where keys
 * are managed externally.
 */

declare class RawKeyCredentialProvider implements CredentialProvider {
    private fiberKey;
    private ckbKey;
    private identifier;
    private locked;
    /**
     * @param fiberKeyPair - 32-byte Fiber P2P identity key
     * @param ckbSecretKey - 32-byte CKB secret key (optional for external funding)
     * @param identifier - Unique identity string for IndexedDB prefix isolation
     */
    constructor(fiberKeyPair: Uint8Array, ckbSecretKey?: Uint8Array, identifier?: string);
    getFiberKeyPair(): Promise<Uint8Array>;
    getCkbSecretKey(): Promise<Uint8Array | undefined>;
    unlock(): Promise<void>;
    lock(): Promise<void>;
    isUnlocked(): boolean;
    getIdentifier(): string;
}

interface CccKnownScriptCellDepLike {
    cellDep: {
        outPoint: {
            txHash: string;
            index: unknown;
        };
        depType: 'code' | 'depGroup';
    };
}
interface CccKnownScriptInfoLike {
    codeHash: string;
    hashType: 'type' | 'data' | 'data1' | 'data2';
    cellDeps: CccKnownScriptCellDepLike[];
}
interface CccScriptLike {
    codeHash: string;
    hashType: 'type' | 'data' | 'data1' | 'data2';
    args: string;
}
type BivariantSignTransaction = {
    bivarianceHack(tx: unknown): Promise<unknown>;
}['bivarianceHack'];
type BivariantGetKnownScript = {
    bivarianceHack(knownScript: string): Promise<CccKnownScriptInfoLike>;
}['bivarianceHack'];
interface CccSignerLike {
    signTransaction: BivariantSignTransaction;
    client: {
        getKnownScript: BivariantGetKnownScript;
    };
}
interface CccRecommendedAddressObjLike {
    script: CccScriptLike;
    toString?: () => string;
}
interface CccFundingSignerLike extends CccSignerLike {
    getRecommendedAddressObj: () => Promise<CccRecommendedAddressObjLike>;
}
interface CreateCccSignFundingTxOptions {
    toRpcTransaction?: (signedTx: unknown) => Record<string, unknown>;
}
interface CccExternalFundingResolved {
    signFundingTx: (txForSigner: unknown) => Promise<unknown>;
    shutdownScript: Script;
    fundingLockScript: Script;
    fundingLockScriptCellDeps?: CellDep[];
    ckbRpcUrl?: string;
}
interface CreateCccExternalFundingResolverOptions {
    signer: CccFundingSignerLike;
    knownScripts?: readonly string[];
    ckbRpcUrl?: string;
    signFundingTxOptions?: CreateCccSignFundingTxOptions;
    onKnownScriptResolved?: (knownScript: string) => void;
    onAddressResolved?: (address: CccRecommendedAddressObjLike) => void;
}
declare function cccScriptToFiberScript(script: CccScriptLike): Script;
declare function resolveFundingLockCellDepsByKnownScript(signer: CccSignerLike, script: Script, knownScripts: readonly string[]): Promise<{
    knownScript: string;
    cellDeps: CellDep[];
} | null>;
declare function createCccSignFundingTx(signer: CccSignerLike, options?: CreateCccSignFundingTxOptions): (txForSigner: unknown) => Promise<Record<string, unknown>>;
declare function createCccExternalFundingResolver<TContext = unknown>(options: CreateCccExternalFundingResolverOptions): (_context: TContext) => Promise<CccExternalFundingResolved>;

declare function callJsonRpc<TResult>(url: string, method: string, params: unknown[]): Promise<TResult>;
declare function getLockBalanceShannons(ckbRpcUrl: string, lockScript: Script, options?: {
    pageSize?: number;
    maxPages?: number;
}): Promise<bigint>;
declare function formatShannonsAsCkb(shannons: bigint | string, fractionDigits?: number): string;

/**
 * Normalize a CKB tx object from Fiber RPC shape (snake_case) to CCC shape (camelCase).
 */
declare function normalizeCkbTransactionForCcc<T>(value: T): T;
/**
 * Normalize a CKB tx object from CCC shape (camelCase) to Fiber RPC shape (snake_case).
 */
declare function normalizeCkbTransactionForRpc<T>(value: T): T;

declare function shouldDiagnoseFundingAbortError(message: string): boolean;
declare function extractRequiredCapacityCkbFromFundingError(message: string): string | null;
declare function computeSuggestedFundingAmountCkb(currentCkb: string, requiredCapacityCkb: string): string | null;
interface DiagnoseExternalFundingFailureOptions {
    node: Pick<IFiberClient, 'listChannels'>;
    rawError: string;
    targetPubkey?: HexString;
    channelIdHint?: HexString;
    fundingLockScript?: Script;
    requestedFundingShannons?: bigint;
    ckbRpcUrl?: string;
}
interface DiagnoseExternalFundingFailureResult {
    channelDiagnostic: string | null;
    balanceDiagnostic: string | null;
    summary: string | null;
}
declare function diagnoseExternalFundingFailure(options: DiagnoseExternalFundingFailureOptions): Promise<DiagnoseExternalFundingFailureResult>;

interface OpenChannelWithExternalFundingFlowResult {
    channelId: OpenChannelWithExternalFundingResult['channel_id'];
    unsignedFundingTx: OpenChannelWithExternalFundingResult['unsigned_funding_tx'];
    signedFundingTx: Record<string, unknown>;
    fundingTxHash: Hash256;
}
interface OpenChannelWithExternalFundingFlowOptions {
    node: Pick<IFiberClient, 'openChannelWithExternalFunding' | 'submitSignedFundingTx'>;
    params: OpenChannelWithExternalFundingParams;
    signFundingTx: (txForSigner: unknown) => Promise<unknown>;
}
/**
 * High-level external funding flow helper.
 *
 * It performs open -> sign -> submit in one call and normalizes tx formats
 * between Fiber RPC (snake_case) and wallet SDKs (camelCase) automatically.
 */
declare function openChannelWithExternalFundingFlow(options: OpenChannelWithExternalFundingFlowOptions): Promise<OpenChannelWithExternalFundingFlowResult>;

/**
 * Parse a UDT amount from cell output_data.
 *
 * UDT cells store the amount as the first 16 bytes of `output_data`, encoded
 * little-endian. This helper validates the data format, reverses the bytes to
 * big-endian, and returns the amount as a bigint.
 *
 * @param data - Cell output_data hex string.
 * @returns The parsed amount, or `null` if the data is malformed.
 */
declare function parseUdtAmountFromCellData(data: string): bigint | null;
declare function getUdtBalance(ckbRpcUrl: string, lockScript: Script, udtTypeScript: Script, options?: {
    pageSize?: number;
    maxPages?: number;
}): Promise<bigint>;

export { AbandonChannelParams, AcceptChannelParams, AcceptChannelResult, type BrowserNodeConfig, type BrowserNodeEvents, type BrowserNodeState, BuildRouterParams, BuildRouterResult, CancelInvoiceParams, CancelInvoiceResult, type CccExternalFundingResolved, type CccFundingSignerLike, type CccKnownScriptCellDepLike, type CccKnownScriptInfoLike, type CccRecommendedAddressObjLike, type CccScriptLike, type CccSignerLike, CellDep, Channel, ChannelId, CkbInvoiceStatus, ConfigBuilder, ConnectPeerParams, type CreateCccExternalFundingResolverOptions, type CreateCccSignFundingTxOptions, type CredentialProvider, type DiagnoseExternalFundingFailureOptions, type DiagnoseExternalFundingFailureResult, DisconnectPeerParams, FiberBrowserNode, type FiberBrowserNodeConfig, FiberWasmAdapter, type FiberWasmFactory, type FiberWasmInstance, GetInvoiceParams, GetInvoiceResult, GetPaymentParams, GetPaymentResult, GraphChannelsParams, GraphChannelsResult, GraphNodesParams, GraphNodesResult, Hash256, HexString, IFiberClient, ListChannelsParams, ListChannelsResult, ListPeersResult, NewInvoiceParams, NewInvoiceResult, NodeInfoResult, OpenChannelParams, OpenChannelResult, type OpenChannelWithExternalFundingFlowOptions, type OpenChannelWithExternalFundingFlowResult, OpenChannelWithExternalFundingParams, OpenChannelWithExternalFundingResult, ParseInvoiceParams, ParseInvoiceResult, PasskeyCredentialProvider, type PasskeySupportReason, type PasskeySupportStatus, PasswordCredentialProvider, type PasswordUnlockParams, PaymentHash, RawKeyCredentialProvider, type RawKeyUnlockParams, Script, SendPaymentParams, SendPaymentResult, SendPaymentWithRouterParams, SettleInvoiceParams, ShutdownChannelParams, type StartOptions, SubmitSignedFundingTxParams, SubmitSignedFundingTxResult, type UdtWhitelistEntry, UpdateChannelParams, type WasmAdapterConfig, type WasmAdapterEvents, type WasmAdapterState, callJsonRpc, cccScriptToFiberScript, computeSuggestedFundingAmountCkb, createCccExternalFundingResolver, createCccSignFundingTx, diagnoseExternalFundingFailure, extractRequiredCapacityCkbFromFundingError, formatShannonsAsCkb, getLockBalanceShannons, getUdtBalance, normalizeCkbTransactionForCcc, normalizeCkbTransactionForRpc, openChannelWithExternalFundingFlow, parseUdtAmountFromCellData, resolveFundingLockCellDepsByKnownScript, shouldDiagnoseFundingAbortError };