import { type AccountWallet, AuthWitness, type AztecAddress, type AztecNode, EthAddress, type FieldsOf, Fr, type L2AmountClaim, type L2AmountClaimWithRecipient, type Logger, type PXE, type SiblingPath, type TxReceipt, type Wallet } from '@aztec/aztec.js';
import { type ExtendedViemWalletClient, type L1ContractAddresses } from '@aztec/ethereum';
import { TokenContract } from '@aztec/noir-contracts.js/Token';
import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
import { type Hex } from 'viem';
/**
 * Deploy L1 token and portal, initialize portal, deploy a non native l2 token contract, its L2 bridge contract and attach is to the portal.
 * @param wallet - the wallet instance
 * @param walletClient - A viem WalletClient.
 * @param publicClient - A viem PublicClient.
 * @param rollupRegistryAddress - address of rollup registry to pass to initialize the token portal
 * @param owner - owner of the L2 contract
 * @param underlyingERC20Address - address of the underlying ERC20 contract to use (if none supplied, it deploys one)
 * @returns l2 contract instance, bridge contract instance, token portal instance, token portal address and the underlying ERC20 instance
 */
export declare function deployAndInitializeTokenAndBridgeContracts(wallet: Wallet, l1Client: ExtendedViemWalletClient, rollupRegistryAddress: EthAddress, owner: AztecAddress, underlyingERC20Address: EthAddress): Promise<{
    /**
     * The L2 token contract instance.
     */
    token: TokenContract;
    /**
     * The L2 bridge contract instance.
     */
    bridge: TokenBridgeContract;
    /**
     * The token portal contract address.
     */
    tokenPortalAddress: EthAddress;
    /**
     * The token portal contract instance
     */
    tokenPortal: any;
    /**
     * The underlying ERC20 contract instance.
     */
    underlyingERC20: any;
}>;
export type CrossChainContext = {
    l2Token: AztecAddress;
    l2Bridge: AztecAddress;
    tokenPortal: EthAddress;
    underlying: EthAddress;
    ethAccount: EthAddress;
    ownerAddress: AztecAddress;
    inbox: EthAddress;
    outbox: EthAddress;
};
/**
 * A Class for testing cross chain interactions, contains common interactions
 * shared between cross chain tests.
 */
export declare class CrossChainTestHarness {
    /** Aztec node instance. */
    aztecNode: AztecNode;
    /** Private eXecution Environment (PXE). */
    pxeService: PXE;
    /** Logger. */
    logger: Logger;
    /** L2 Token contract. */
    l2Token: TokenContract;
    /** L2 Token bridge contract. */
    l2Bridge: TokenBridgeContract;
    /** Eth account to interact with. */
    ethAccount: EthAddress;
    /** Portal address. */
    tokenPortalAddress: EthAddress;
    /** Underlying token for portal tests. */
    underlyingERC20Address: EthAddress;
    /** Viem Extended client instance. */
    l1Client: ExtendedViemWalletClient;
    /** Deployment addresses for all L1 contracts */
    readonly l1ContractAddresses: L1ContractAddresses;
    /** Wallet of the owner. */
    readonly ownerWallet: AccountWallet;
    /** Owner of the l2 token and bridge */
    readonly ownerAddress: AztecAddress;
    static new(aztecNode: AztecNode, pxeService: PXE, l1Client: ExtendedViemWalletClient, wallet: AccountWallet, ownerAddress: AztecAddress, logger: Logger, underlyingERC20Address: EthAddress): Promise<CrossChainTestHarness>;
    private readonly l1TokenManager;
    private readonly l1TokenPortalManager;
    constructor(
    /** Aztec node instance. */
    aztecNode: AztecNode, 
    /** Private eXecution Environment (PXE). */
    pxeService: PXE, 
    /** Logger. */
    logger: Logger, 
    /** L2 Token contract. */
    l2Token: TokenContract, 
    /** L2 Token bridge contract. */
    l2Bridge: TokenBridgeContract, 
    /** Eth account to interact with. */
    ethAccount: EthAddress, 
    /** Portal address. */
    tokenPortalAddress: EthAddress, 
    /** Underlying token for portal tests. */
    underlyingERC20Address: EthAddress, 
    /** Viem Extended client instance. */
    l1Client: ExtendedViemWalletClient, 
    /** Deployment addresses for all L1 contracts */
    l1ContractAddresses: L1ContractAddresses, 
    /** Wallet of the owner. */
    ownerWallet: AccountWallet, 
    /** Owner of the l2 token and bridge */
    ownerAddress: AztecAddress);
    mintTokensOnL1(amount: bigint): Promise<void>;
    getL1BalanceOf(address: EthAddress): Promise<bigint>;
    sendTokensToPortalPublic(bridgeAmount: bigint, mint?: boolean): Promise<L2AmountClaim>;
    sendTokensToPortalPrivate(bridgeAmount: bigint, mint?: boolean): Promise<L2AmountClaimWithRecipient>;
    mintTokensPublicOnL2(amount: bigint): Promise<void>;
    mintTokensPrivateOnL2(amount: bigint): Promise<void>;
    sendL2PublicTransfer(transferAmount: bigint, receiverAddress: AztecAddress): Promise<void>;
    consumeMessageOnAztecAndMintPrivately(claim: Pick<L2AmountClaimWithRecipient, 'claimAmount' | 'claimSecret' | 'messageLeafIndex' | 'recipient'>): Promise<void>;
    consumeMessageOnAztecAndMintPublicly(claim: Pick<L2AmountClaim, 'claimAmount' | 'claimSecret' | 'messageLeafIndex'>): Promise<void>;
    withdrawPrivateFromAztecToL1(withdrawAmount: bigint, authwitNonce: Fr | undefined, authWitness: AuthWitness): Promise<FieldsOf<TxReceipt>>;
    withdrawPublicFromAztecToL1(withdrawAmount: bigint, authwitNonce?: Fr): Promise<FieldsOf<TxReceipt>>;
    getL2PrivateBalanceOf(owner: AztecAddress): Promise<any>;
    expectPrivateBalanceOnL2(owner: AztecAddress, expectedBalance: bigint): Promise<void>;
    getL2PublicBalanceOf(owner: AztecAddress): Promise<any>;
    expectPublicBalanceOnL2(owner: AztecAddress, expectedBalance: bigint): Promise<void>;
    getL2ToL1MessageLeaf(withdrawAmount: bigint, callerOnL1?: EthAddress): Promise<Fr>;
    withdrawFundsFromBridgeOnL1(amount: bigint, blockNumber: number | bigint, messageIndex: bigint, siblingPath: SiblingPath<number>): Promise<void>;
    transferToPrivateOnL2(shieldAmount: bigint): Promise<void>;
    transferToPublicOnL2(amount: bigint, authwitNonce?: Fr): Promise<void>;
    /**
     * Makes message available for consumption.
     * @dev Does that by performing 2 unrelated transactions on L2 to progress the rollup by 2 blocks and then waits for
     * message to be processed by archiver. We need to progress by 2 because there is a 1 block lag between when
     * the message is sent to Inbox and when the subtree containing the message is included in the block and then when
     * it's included it becomes available for consumption in the next block because the l1 to l2 message tree.
     */
    makeMessageConsumable(msgHash: Fr | Hex): Promise<void>;
    toCrossChainContext(): CrossChainContext;
}
//# sourceMappingURL=cross_chain_test_harness.d.ts.map