import { BN } from "@coral-xyz/anchor";
import { PublicKey, VersionedTransaction, TransactionSignature, Keypair, Commitment, Finality, TransactionInstruction, VersionedTransactionResponse } from "@solana/web3.js";
import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "./base";
import { CctpPolicy } from "../deser/integrationPolicies";
export declare class CctpBridgeEvent {
    readonly amount: BN;
    readonly sourceDomain: number;
    readonly sourceAddress: string;
    readonly destinationDomain: number;
    readonly destinationCaller: string;
    readonly destinationAddress: string;
    readonly attestation: string;
    readonly nonce: string;
    readonly status: string;
    readonly txHash: string;
    readonly uiAmount: number;
    slot?: number;
    constructor(amount: BN, sourceDomain: number, sourceAddress: string, destinationDomain: number, destinationCaller: string, destinationAddress: string, attestation: string, nonce: string, status: string, txHash: string);
}
declare class TxBuilder extends BaseTxBuilder<CctpClient> implements ProtocolPolicyTxBuilder<CctpPolicy> {
    /**
     * Returns a transaction that calls CCTP's `depositForBurn` instruction that bridges USDC to another chain.
     * A keypair is generated for the message sent event account, which must be included as a transaction signer.
     */
    bridgeUsdcIx(amount: BN, domain: number, destinationAddress: PublicKey, params: {
        maxFee: BN;
        minFinalityThreshold: number;
        destinationCaller?: PublicKey;
    }, glamSigner: PublicKey): Promise<[TransactionInstruction, Keypair]>;
    bridgeUsdcTx(amount: BN, domain: number, destinationAddress: PublicKey, params: {
        maxFee: BN;
        minFinalityThreshold: number;
        destinationCaller?: PublicKey;
    }, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
    receiveMessageIx(sourceDomain: number, messageObj: any): Promise<TransactionInstruction>;
    receiveUsdcTx(sourceDomain: number, params: {
        txHash?: string;
        nonce?: string;
    }, txOptions?: TxOptions): Promise<VersionedTransaction>;
    setPolicyIx(policy: CctpPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
    setPolicyTx(policy: CctpPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
}
export declare class CctpClient implements ProtocolPolicyClient<CctpPolicy> {
    readonly base: BaseClient;
    txBuilder: TxBuilder;
    constructor(base: BaseClient);
    /**
     * Bridge USDC to another chain using Circle's CCTP protocol
     *
     * @param amount Amount of USDC to bridge (in smallest units)
     * @param domain Destination domain (e.g., 0 for Ethereum, 1 for Avalanche)
     * @param destinationAddress Destination address on target chain (EVM address as PublicKey)
     * @param params Additional parameters (maxFee, minFinalityThreshold)
     * @param txOptions Transaction options
     */
    bridgeUsdc(amount: BN | number, domain: number, destinationAddress: PublicKey, params: {
        maxFee: BN;
        minFinalityThreshold: number;
        destinationCaller?: PublicKey;
    }, txOptions?: TxOptions): Promise<TransactionSignature>;
    /**
     * Receive USDC from another chain using Circle's CCTP protocol
     *
     * @param sourceDomain Source domain (e.g., 0 for Ethereum, 6 for Base)
     * @param params Additional parameters (txHash, nonce)
     * @param txOptions Transaction options
     */
    receiveUsdc(sourceDomain: number, params: {
        txHash?: string;
        nonce?: string;
    }, txOptions?: TxOptions): Promise<string>;
    fetchPolicy(): Promise<CctpPolicy | null>;
    setPolicy(policy: CctpPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
    getReceiveMessagePdas(messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, solUsdcMint: PublicKey, remoteUsdcAddressHex: string, remoteDomain: string, nonceHex: string): Promise<{
        messageTransmitter: PublicKey;
        tokenMessenger: PublicKey;
        tokenMinter: PublicKey;
        localToken: PublicKey;
        remoteTokenMessengerKey: PublicKey;
        remoteTokenKey: PublicKey;
        tokenPair: PublicKey;
        custodyTokenAccount: PublicKey;
        authorityPda: PublicKey;
        tokenMessengerEventAuthority: PublicKey;
        usedNonce: PublicKey;
        feeRecipientTokenAccount: PublicKey;
    }>;
    /**
     * Get all PDAs required for CCTP deposit for burn operation
     *
     * @param messageTransmitterProgram Message transmitter program ID
     * @param tokenMessengerMinterProgram Token messenger minter program ID
     * @param usdcAddress USDC mint address
     * @param destinationDomain Destination domain
     * @returns Object containing all required PDAs
     */
    getDepositForBurnPdas(messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, usdcAddress: PublicKey, destinationDomain: Number): {
        messageTransmitterAccount: PublicKey;
        tokenMessengerAccount: PublicKey;
        tokenMinterAccount: PublicKey;
        localToken: PublicKey;
        remoteTokenMessengerKey: PublicKey;
        authorityPda: PublicKey;
        tokenMessengerEventAuthority: PublicKey;
    };
    /**
     * Find all message accounts onchain for a given sender wallet
     *
     * TODO: filter by burned token mint
     */
    findV2Messages(senderWallet: PublicKey, options: {
        commitment?: Commitment;
        minSlot?: number;
    }): Promise<PublicKey[]>;
    fetchV2Messages(sourceDomain: number, params: {
        txHash?: string;
        nonce?: string;
    }): Promise<any[]>;
    /**
     * Get bridge events from Circle API using either txHash or nonce
     *
     * @param sourceDomain Source domain
     * @param params Either txHash or nonce is required
     * @returns Array of bridge events
     */
    parseEventsFromAttestion(sourceDomain: number, { txHash, nonce }: {
        txHash?: string;
        nonce?: string;
    }): Promise<CctpBridgeEvent[]>;
    getTransactions(signatures: string[], batchSize: number, commitment?: Finality): Promise<VersionedTransactionResponse[]>;
    /**
     * Get incoming bridge events (EVM -> Solana)
     *
     * Unlike outgoing bridge events, incoming bridge events are not stored in Message accounts on Solana.
     * We need to examine all transactions to find the ones that contain the bridge events.
     * 1. Fetch all transactions involing the vault's USDC token account
     * 2. Filter transactions that contain the bridge events
     * 3. Parse the bridge events from the transactions
     */
    getIncomingBridgeEvents(options: {
        batchSize?: number;
        commitment?: Finality;
        txHashes?: string[];
        minSlot?: number;
    }): Promise<CctpBridgeEvent[]>;
    /**
     * Get outgoing bridge events (Solana -> EVM)
     *
     * Each transfer has a Message account on Solana. To get all events:
     * 1. Find all Message accounts for the vault
     * 2. Get the created transaction for each message account
     * 3. Call iris api to get the attestation status and parsed message using each tx hash
     */
    getOutgoingBridgeEvents(options: {
        batchSize?: number;
        commitment?: Commitment;
        txHashes?: string[];
        minSlot?: number;
    }): Promise<CctpBridgeEvent[]>;
}
export {};