@glamsystems/glam-sdk 1.1.0 → 1.1.1-alpha.0

package/src/client/base.d.ts

@@ -1,234 +0,0 @@
-import * as anchor from "@coral-xyz/anchor";
-import { BN } from "@coral-xyz/anchor";
-import { Wallet } from "@coral-xyz/anchor";
-import { Connection, Keypair, PublicKey, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { type LookupTableInput } from "../utils/lookupTables";
-import { ExtBridgeProgram, ExtEpiProgram, ExtCctpProgram, ExtJupiterProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtLoopscaleProgram, ExtPhoenixProgram, ExtOrcaProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
-import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
-import { GlobalConfig } from "../globalConfig";
-import { RequestQueue, StateAccount, StateModel } from "../models";
-import { BlockhashWithCache } from "../utils/blockhash";
-import { JupiterApiClient, PhoenixApiClient, PkMap } from "../utils";
-import { AssetMeta } from "../assets";
-export type TxOptions = {
-    signer?: PublicKey;
-    computeUnitLimit?: number;
-    getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
-    maxFeeLamports?: number;
-    useMaxFee?: boolean;
-    preInstructions?: TransactionInstruction[];
-    postInstructions?: TransactionInstruction[];
-    lookupTables?: LookupTableInput[];
-    simulate?: boolean;
-};
-export interface ProtocolPolicyTxBuilder<TPolicy> {
-    setPolicyIx(policy: TPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: TPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export interface ProtocolPolicyClient<TPolicy> {
-    fetchPolicy(): Promise<TPolicy | null>;
-    setPolicy(policy: TPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export type TokenAccount = {
-    owner: PublicKey;
-    pubkey: PublicKey;
-    mint: PublicKey;
-    programId: PublicKey;
-    decimals: number;
-    amount: string;
-    uiAmount: number;
-    frozen: boolean;
-};
-export declare class BaseClient {
-    cluster: ClusterNetwork;
-    provider: anchor.Provider;
-    blockhashWithCache: BlockhashWithCache;
-    jupiterApiKey?: string;
-    jupiterApiClient?: JupiterApiClient;
-    phoenixApiUrl?: string;
-    phoenixApiClient?: PhoenixApiClient;
-    onSentListeners: Set<(sig: string) => void>;
-    readonly staging: boolean;
-    private _protocolProgram?;
-    private _mintProgram?;
-    private _extSplProgram?;
-    private _extKaminoProgram?;
-    private _extMarinadeProgram?;
-    private _extStakePoolProgram?;
-    private _extCctpProgram?;
-    private _extBridgeProgram?;
-    private _extEpiProgram?;
-    private _extLoopscaleProgram?;
-    private _extPhoenixProgram?;
-    private _extJupiterProgram?;
-    private _extOrcaProgram?;
-    private _statePda?;
-    private _globalConfig?;
-    private _globalConfigPromise?;
-    private _assetMetas?;
-    private _assetMetasPromise?;
-    private _defaultLookupTablesPromise?;
-    private _glamLookupTablesPromise?;
-    private _glamLookupTablesCacheKey?;
-    constructor(config?: GlamClientConfig);
-    get protocolProgram(): GlamProtocolProgram;
-    get mintProgram(): GlamMintProgram;
-    get extSplProgram(): ExtSplProgram;
-    get extKaminoProgram(): ExtKaminoProgram;
-    get extMarinadeProgram(): ExtMarinadeProgram;
-    get extStakePoolProgram(): ExtStakePoolProgram;
-    get extCctpProgram(): ExtCctpProgram;
-    get extBridgeProgram(): ExtBridgeProgram;
-    get extEpiProgram(): ExtEpiProgram;
-    get extLoopscaleProgram(): ExtLoopscaleProgram;
-    get extPhoenixProgram(): ExtPhoenixProgram;
-    get extJupiterProgram(): ExtJupiterProgram;
-    get extOrcaProgram(): ExtOrcaProgram;
-    get isVaultConnected(): boolean;
-    get statePda(): PublicKey;
-    set statePda(statePda: PublicKey);
-    /**
-     * Mainnet-only default lookup tables (Kamino lending, Loopscale).
-     * Cached for the session; safe to assume static contents.
-     */
-    private getDefaultLookupTables;
-    /**
-     * Discovers GLAM ALTs for the connected vault and caches the result for the
-     * session.
-     *
-     * Call `invalidateGlamLookupTablesCache()` after creating or extending an ALT
-     * to force a re-discovery on the next tx.
-     */
-    private getGlamLookupTablesCached;
-    invalidateGlamLookupTablesCache(): void;
-    private warmupGlamLookupTables;
-    get isMainnet(): boolean;
-    /**
-     * Converts a legacy transaction into a versioned transaction.
-     */
-    intoVersionedTransaction(tx: Transaction, { lookupTables, signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee, simulate, }: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Signs, sends, and confirms a transaction.
-     *
-     * Legacy transactions receive missing fee-payer/blockhash values here and
-     * extra signers are applied with `partialSign` before wallet signing.
-     * Versioned transactions are expected to be fully built by the caller; extra
-     * signers are applied after wallet signing so this remains compatible with
-     * transactions created by another `@solana/web3.js` package instance.
-     *
-     * Transactions are sent with preflight disabled because callers commonly
-     * simulate while building compute-budget instructions.
-     */
-    sendAndConfirm(tx: VersionedTransaction | Transaction, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
-    private confirmTransaction;
-    get connection(): Connection;
-    get signer(): PublicKey;
-    get wallet(): Wallet;
-    get vaultPda(): PublicKey;
-    get mintPda(): PublicKey;
-    get escrowPda(): PublicKey;
-    get extraMetasPda(): PublicKey;
-    get requestQueuePda(): PublicKey;
-    /**
-     * Returns SOL and token balances of the given owner pubkey
-     */
-    getSolAndTokenBalances(owner: PublicKey): Promise<{
-        balanceLamports: number;
-        uiAmount: number;
-        tokenAccounts: TokenAccount[];
-    }>;
-    /**
-     * Returns user's token account for the given mint and token program ID
-     */
-    getAta(mint: PublicKey, owner: PublicKey, tokenProgram?: anchor.web3.PublicKey): PublicKey;
-    /**
-     * Returns glam vault's token account for the given mint and token program ID
-     */
-    getVaultAta(mint: PublicKey, tokenProgramId?: PublicKey): PublicKey;
-    /**
-     * Returns user's glam mint token account
-     */
-    getMintAta(user?: PublicKey): PublicKey;
-    /**
-     * Returns glam vault's SOL balance
-     */
-    getVaultBalance(): Promise<number>;
-    /**
-     * Returns glam vault's SOL balance in lamports
-     */
-    getVaultLamports(): Promise<number>;
-    /**
-     * Returns glam vault's token balance for the given mint
-     */
-    getVaultTokenBalance(mintPubkey: PublicKey): Promise<{
-        amount: BN;
-        uiAmount: number;
-    }>;
-    /**
-     * Returns user's glam mint token balance
-     */
-    getMintTokenBalance(owner?: PublicKey): Promise<{
-        amount: BN;
-        uiAmount: number;
-    }>;
-    isLockupEnabled(): Promise<boolean>;
-    fetchGlobalConfig(options?: {
-        refresh?: boolean;
-    }): Promise<GlobalConfig>;
-    fetchAssetMetas(options?: {
-        refresh?: boolean;
-    }): Promise<PkMap<AssetMeta>>;
-    refreshAssetMetaCache(): Promise<PkMap<AssetMeta>>;
-    getAssetMeta(assetMint: string | PublicKey, options?: {
-        refresh?: boolean;
-    }): Promise<AssetMeta>;
-    getSolOracle(options?: {
-        refresh?: boolean;
-    }): Promise<PublicKey>;
-    fetchStateAccount(statePda?: PublicKey): Promise<StateAccount>;
-    private getMintProgramIdForStateAccount;
-    private getMintProgramForStateAccount;
-    fetchRequestQueue(requestQueuePda?: PublicKey, mintProgram?: GlamMintProgram): Promise<RequestQueue>;
-    /**
-     * Builds a StateModel from onchain accounts (state, mint, etc)
-     *
-     * @param statePda Optional state PDA
-     */
-    fetchStateModel(statePda?: PublicKey): Promise<StateModel>;
-    /**
-     * Fetches glam state models and applies filters
-     *
-     * @param filterOptions Filter options
-     */
-    fetchGlamStates(filterOptions?: {
-        owner?: PublicKey;
-        delegate?: PublicKey;
-        type?: string;
-    }): Promise<StateModel[]>;
-    fetchProtocolPolicy<T>(integProgramId: PublicKey, protocolBitflag: number, policyClass: {
-        decode(buffer: Buffer, staging?: boolean): T;
-    }): Promise<T | null>;
-}
-/**
- * Base transaction builder for sub-clients
- */
-export declare class BaseTxBuilder<T extends {
-    base: BaseClient;
-}> {
-    readonly client: T;
-    constructor(client: T);
-    clearProtocolPolicyIx(integrationProgram: PublicKey, protocolBitflag: number, signer?: PublicKey): Promise<TransactionInstruction>;
-    clearProtocolPolicyTx(integrationProgram: PublicKey, protocolBitflag: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Build a legacy transaction with the given instructions.
-     * Pre and post instructions in txOptions are preserved.
-     */
-    build(ixs: TransactionInstruction[], txOptions?: TxOptions): Transaction;
-    /**
-     * Build a versioned transaction that is ready to be sent.
-     */
-    buildVersionedTx(ixs: TransactionInstruction[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-}

package/src/client/bridge.d.ts

@@ -1,205 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { Keypair, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, ProtocolPolicyClient, ProtocolPolicyTxBuilder, TxOptions } from "./base";
-import { LayerzeroOftRouteProfile } from "./bridgeRegistry";
-import { LayerzeroOftPolicy, LayerzeroOftRoute, RouteManagementMode } from "../deser/integrationPolicies";
-type BufferLike = Uint8Array | number[] | Buffer;
-type RouteManagementModeArg = RouteManagementMode | number | {
-    unmanagedOnly: Record<string, never>;
-} | {
-    managedOnly: Record<string, never>;
-} | {
-    either: Record<string, never>;
-};
-export type LayerzeroOftRouteInput = Omit<LayerzeroOftRoute, "managementMode"> & {
-    managementMode: RouteManagementModeArg;
-};
-export type OftTransferParams = {
-    transferId: PublicKey;
-    sourceMint: PublicKey;
-    sourceAmount: BN;
-    providerInstructions: TransactionInstruction[];
-    providerReceipt: PublicKey;
-    managed?: boolean;
-    providerSigners?: Keypair[];
-};
-export type LayerzeroOftSendParams = {
-    transferId?: PublicKey;
-    sourceMint: PublicKey;
-    sourceAmount: BN;
-    destinationChain: number;
-    destinationRecipient: PublicKey;
-    nativeFeeLamports: BN;
-    minAmountLd?: BN;
-    lzTokenFee?: BN;
-    options?: BufferLike;
-    composeMsg?: BufferLike | null;
-    sourceTokenAccount?: PublicKey;
-    nonceAccount?: PublicKey;
-    managed?: boolean;
-    providerProgram?: PublicKey;
-};
-type BridgeTransferStatusAccount = {
-    committed: Record<string, never>;
-} | {
-    validated: Record<string, never>;
-} | {
-    settled: Record<string, never>;
-};
-type BridgeTransferRecordAccount = {
-    glamState: PublicKey;
-    transferId: PublicKey;
-    protocol: number;
-    status: BridgeTransferStatusAccount;
-    managed: true;
-    receiptVerified: true;
-    sourceMint: PublicKey;
-    sourceDecimals: number;
-    providerProgram: PublicKey;
-    providerConfig: PublicKey;
-    sourceAmount: BN;
-    quotedOutAmount: BN;
-    destinationChain: number;
-    destinationRecipient: PublicKey;
-    providerEmitter: PublicKey;
-    providerSequence: BN;
-    committedSlot: BN;
-};
-export declare function getActiveRegistryTransfers(registry: {
-    managedTransferCount: BN | number;
-    transfers: any[];
-}): any[];
-export declare function deriveLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
-export declare function deriveOftAuxiliaryAccountSeed(glamState: PublicKey, transferId: PublicKey): Promise<string>;
-export declare function deriveOftAuxiliaryAccount(glamSigner: PublicKey, glamState: PublicKey, transferId: PublicKey, tokenProgram: PublicKey): Promise<{
-    address: PublicKey;
-    seed: string;
-}>;
-declare class TxBuilder extends BaseTxBuilder<BridgeClient> implements ProtocolPolicyTxBuilder<LayerzeroOftPolicy> {
-    setPolicyIx(policy: LayerzeroOftPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: LayerzeroOftPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    addLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
-    updateLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
-    deleteLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
-    buildOftTransferTx(params: OftTransferParams, txOptions?: TxOptions): Promise<{
-        tx: VersionedTransaction;
-        additionalSigners: Keypair[];
-        sessionPda: PublicKey;
-        auxiliaryTokenAccount: PublicKey;
-        sourceTokenAccount: PublicKey;
-    }>;
-}
-declare class LayerzeroOftBridgeProtocolClient {
-    readonly bridge: BridgeClient;
-    constructor(bridge: BridgeClient);
-    buildSendTx(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<{
-        auxiliaryTokenAccount: PublicKey;
-        nonceAccount: PublicKey;
-        routeProfile: LayerzeroOftRouteProfile;
-        sendInstruction: TransactionInstruction;
-        tx: VersionedTransaction;
-        additionalSigners: Keypair[];
-        sessionPda: PublicKey;
-        sourceTokenAccount: PublicKey;
-    }>;
-    send(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export declare class BridgeClient implements ProtocolPolicyClient<LayerzeroOftPolicy> {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    readonly oft: LayerzeroOftBridgeProtocolClient;
-    constructor(base: BaseClient);
-    getRegistryPda(): PublicKey;
-    getSessionPda(transferId: PublicKey): PublicKey;
-    getLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
-    deriveOftAuxiliaryTokenAccount(transferId: PublicKey, sourceMint: PublicKey, signer?: PublicKey): Promise<{
-        tokenProgram: PublicKey;
-        address: PublicKey;
-        seed: string;
-    }>;
-    private resolveLayerzeroOftRouteProfile;
-    private resolveLayerzeroOftNonceAccount;
-    private materializeLayerzeroOftRemainingAccounts;
-    private buildLayerzeroOftInstructionBaseAccounts;
-    private buildLayerzeroOftSendInstruction;
-    fetchPolicy(): Promise<LayerzeroOftPolicy | null>;
-    fetchLayerzeroOftPolicy(): Promise<LayerzeroOftPolicy | null>;
-    setPolicy(policy: LayerzeroOftPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchRegistry(): Promise<{
-        glamState: PublicKey;
-        managedTransferCount: number;
-        reserved: number[];
-        transfers: {
-            transferId: PublicKey;
-            sourceMint: PublicKey;
-            destinationRecipient: PublicKey;
-            providerProgram: PublicKey;
-            providerConfig: PublicKey;
-            providerEmitter: PublicKey;
-            sourceAmount: BN;
-            quotedOutAmount: BN;
-            providerSequence: BN;
-            committedSlot: BN;
-            protocol: number;
-            destinationChain: number;
-            sourceDecimals: number;
-            status: number;
-            reserved: number[];
-        }[];
-    } | null>;
-    fetchSession(transferId: PublicKey): Promise<{
-        glamState: PublicKey;
-        signer: PublicKey;
-        transferId: PublicKey;
-        protocol: number;
-        managed: boolean;
-        sourceMint: PublicKey;
-        sourceDecimals: number;
-        sourceTokenAccount: PublicKey;
-        providerProgram: PublicKey;
-        providerConfig: PublicKey;
-        providerSender: PublicKey;
-        providerDelegate: PublicKey;
-        providerReceipt: PublicKey;
-        providerInstructionHash: number[];
-        providerInstructionCount: number;
-        sourceAmount: BN;
-        quotedOutAmount: BN;
-        initialSourceBalance: BN;
-        initialProviderSequence: BN;
-        destinationChain: number;
-        destinationRecipient: PublicKey;
-        quoteExpiresAt: BN;
-        preparedSlot: BN;
-        bump: number;
-    } | null>;
-    fetchTransferRecordNullable(transferId: PublicKey): Promise<BridgeTransferRecordAccount | null>;
-    addLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
-    deleteLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
-    buildOftTransferTx(params: OftTransferParams, txOptions?: TxOptions): Promise<{
-        tx: VersionedTransaction;
-        additionalSigners: Keypair[];
-        sessionPda: PublicKey;
-        auxiliaryTokenAccount: PublicKey;
-        sourceTokenAccount: PublicKey;
-    }>;
-    buildLayerzeroOftSendTx(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<{
-        auxiliaryTokenAccount: PublicKey;
-        nonceAccount: PublicKey;
-        routeProfile: LayerzeroOftRouteProfile;
-        sendInstruction: TransactionInstruction;
-        tx: VersionedTransaction;
-        additionalSigners: Keypair[];
-        sessionPda: PublicKey;
-        sourceTokenAccount: PublicKey;
-    }>;
-    sendOft(params: OftTransferParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    private extendLookupTables;
-    settleManagedTransfer(transferId: PublicKey, txOptions?: TxOptions): Promise<string>;
-    validateManagedTransfer(transferId: PublicKey, txOptions?: TxOptions): Promise<string>;
-}
-export {};

package/src/client/bridgeRegistry.d.ts

@@ -1,32 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import { ClusterNetwork } from "../clientConfig";
-export type RouteAccountPlaceholder = "payer" | "nonce";
-export type SerializableRouteAccountMeta = {
-    pubkey?: PublicKey;
-    placeholder?: RouteAccountPlaceholder;
-    isSigner: boolean;
-    isWritable: boolean;
-};
-export type LayerzeroOftRouteProfile = {
-    sourceMint: PublicKey;
-    destinationChain: number;
-    providerProgram: PublicKey;
-    providerConfig: PublicKey;
-    nonceAccount?: PublicKey;
-    peerConfig: PublicKey;
-    providerSender: PublicKey;
-    enforcedOptions: PublicKey;
-    tokenEscrow: PublicKey;
-    eventAuthority: PublicKey;
-    lookupTables?: PublicKey[];
-    defaultOptions?: Uint8Array | number[] | Buffer;
-    defaultMinAmountBps?: number;
-    remainingAccounts: SerializableRouteAccountMeta[];
-    quoteRemainingAccounts?: SerializableRouteAccountMeta[];
-};
-export declare function resolveCanonicalLayerzeroOftRouteProfile(params: {
-    sourceMint: PublicKey;
-    destinationChain: number;
-    cluster: ClusterNetwork;
-    providerProgram?: PublicKey;
-}): LayerzeroOftRouteProfile | null;

package/src/client/cctp.d.ts

@@ -1,164 +0,0 @@
-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 {};