import Big from 'big.js';
import { Maybe } from '@avalabs/core-utils-sdk';
import { TransactionResponse, Block, Provider, JsonRpcProvider, JsonRpcApiProvider, TransactionRequest } from 'ethers';
import { VsCurrencyType } from '@avalabs/core-coingecko-sdk';
import { Psbt } from 'bitcoinjs-lib';
import * as _avalabs_core_wallets_sdk from '@avalabs/core-wallets-sdk';
import { BitcoinInputUTXO, BitcoinOutputUTXO, BitcoinInputUTXOWithOptionalScript, BitcoinProvider } from '@avalabs/core-wallets-sdk';
import { BridgeConfig as BridgeConfig$1 } from 'types';

declare enum Blockchain {
    AVALANCHE = "avalanche",
    ETHEREUM = "ethereum",
    BITCOIN = "bitcoin",
    UNKNOWN = ""
}
declare enum NetworkType {
    MAINNET = "mainnet",
    TESTNET = "testnet"
}
declare enum Environment {
    DEV = "development",
    STAGING = "staging",
    TEST = "test",
    PROD = "prod"
}
interface RuntimeConfig {
    environment: Environment;
    bridgeUrl: string;
    tokenInfoUrl: string;
    configMismatchThreshold: number;
    wardenConfigURLs: string[];
    avalancheNetworkConfig: AddEthereumChainParameter;
    ethereumNetworkConfig: {
        chainId: number;
        rpcUrls: string[];
    };
    disabledTokensOnNetwork: Partial<Record<Blockchain, string[]>>;
}
interface EthereumCriticalConfigBase extends CriticalConfigBase {
    networks: Partial<Record<Blockchain, number | undefined>>;
    walletAddresses: Partial<Record<Blockchain, string>>;
    addressBlocklist: string[];
}
interface EthereumStaticFeeCriticalConfig extends EthereumCriticalConfigBase {
    assets: EthereumStaticFeeConfigAssets;
    useNewFeeStructure?: false;
}
interface EthereumDynamicFeeCriticalConfig extends EthereumCriticalConfigBase {
    assets: EthereumDynamicFeeConfigAssets;
    useNewFeeStructure: true;
}
interface EthereumNonCriticalConfigBase {
    minimumConfirmations: Partial<Record<Blockchain, number | undefined>>;
    currentEthPrice: string;
    currentAvaxPrice: string;
    currentGasPrices: Record<Blockchain.AVALANCHE | Blockchain.ETHEREUM, {
        nextBaseFee: string;
        suggestedTip: string;
    }>;
    /** Timestamp */
    updated: string;
    useChainlinkAssetPriceFeeds?: boolean;
    chainlinkAvaxUsdFeedAddress?: string;
    chainlinkEthUsdFeedAddress?: string;
    chainlinkBtcUsdFeedAddress?: string;
    /** Timestamp */
    startupTime: string;
}
interface EthereumStaticFeeNonCriticalConfig extends EthereumNonCriticalConfigBase {
    unwrapFeeApproximation: Record<string, string>;
    wrapFeeApproximation: Record<string, string>;
}
interface EthereumDynamicFeeNonCriticalConfig extends EthereumNonCriticalConfigBase {
    unwrapFeeApproximation: Record<string, DynamicFeeEstimation>;
    wrapFeeApproximation: Record<string, DynamicFeeEstimation>;
}
interface CriticalConfigBase {
    disableFrontend: boolean;
    operationMode: string;
    operatorEvmAddress?: string;
    operatorAddress: string;
    targetSecretVersion?: number;
    useEip1559TransactionFormat?: boolean;
}
interface BitcoinCriticalConfigBase extends CriticalConfigBase {
    addressBlocklist: string[];
    avalancheChainId: number;
    useEip1559TransactionFormat: boolean;
    walletAddresses: {
        avalanche: string;
        btc: string;
    };
    offboardDelaySeconds: number;
}
interface BitcoinStaticFeeCriticalConfig extends BitcoinCriticalConfigBase {
    bitcoinAssets: BitcoinStaticFeeConfigAssets;
    useNewFeeStructure?: false;
}
interface BitcoinDynamicFeeCriticalConfig extends BitcoinCriticalConfigBase {
    bitcoinAssets: BitcoinDynamicFeeConfigAssets;
    useNewFeeStructure: true;
}
interface BitcoinStaticBridgeFeeEstimate {
    wrapFeeAmount: number;
    constUnwrapFeeAmount: number;
    unwrapFeeNumerator: number;
    unwrapFeeDenominator: number;
    dustThreshold: number;
}
interface BitcoinDynamicBridgeFeeEstimate {
    dustThreshold: number;
    wrapFeeEstimate: DynamicFeeEstimation;
    unwrapFeeEstimate: {
        bridgeToll: DynamicFeeEstimation;
        estimatedTxFee: {
            constAmount: number;
            numeratorPerSat: number;
            denominatorPerSat: number;
        };
    };
}
interface BitcoinNetworkInfoBase {
    minimumConfirmations: number;
    minimumOnboardSize: number;
    currentPrice: string;
    currentFeeRate: {
        feeRate: number;
        source: string;
    };
    currentUtxoStatistics: {
        [hash: string]: {
            mean: string;
            count: string;
        };
    };
    reserveBalance: number;
    networkView: {
        lastIndexedBlock: number;
        lastSeenBlock: number;
        nodeVersion: string;
    };
}
interface BitcoinStaticFeeNetworkInfo extends BitcoinNetworkInfoBase {
    currentBridgeFeeEstimate: BitcoinStaticBridgeFeeEstimate;
}
interface BitcoinDynamicFeeNetworkInfo extends BitcoinNetworkInfoBase {
    currentBridgeFeeEstimate: BitcoinDynamicBridgeFeeEstimate;
}
interface BitcoinNonCriticalConfig<T> {
    networkInfo: {
        btc: T;
    };
    /** Timestamp */
    updated: string;
}
interface BitcoinStaticFeeConfig {
    criticalBitcoin: BitcoinStaticFeeCriticalConfig;
    nonCriticalBitcoin: BitcoinNonCriticalConfig<BitcoinStaticFeeNetworkInfo>;
}
interface BitcoinDynamicFeeConfig {
    criticalBitcoin: BitcoinDynamicFeeCriticalConfig;
    nonCriticalBitcoin: BitcoinNonCriticalConfig<BitcoinDynamicFeeNetworkInfo>;
}
interface EthereumStaticFeeConfig {
    critical: EthereumStaticFeeCriticalConfig;
    nonCritical: EthereumStaticFeeNonCriticalConfig;
}
interface EthereumDynamicFeeConfig {
    critical: EthereumDynamicFeeCriticalConfig;
    nonCritical: EthereumDynamicFeeNonCriticalConfig;
}
interface AppConfigBase {
    startupTime: string;
    version: string;
}
interface AppConfigWithDynamicFeesForEthereum extends AppConfigBase, EthereumDynamicFeeConfig, BitcoinStaticFeeConfig {
}
interface AppConfigWithDynamicFeesForBitcoin extends AppConfigBase, EthereumStaticFeeConfig, BitcoinDynamicFeeConfig {
}
type AppConfigWithStaticFeesForEthereum = AppConfigWithFullStaticFees | AppConfigWithDynamicFeesForBitcoin;
type AppConfigWithStaticFeesForBitcoin = AppConfigWithFullStaticFees | AppConfigWithDynamicFeesForEthereum;
interface AppConfigWithFullDynamicFees extends AppConfigBase, EthereumDynamicFeeConfig, BitcoinDynamicFeeConfig {
}
interface AppConfigWithFullStaticFees extends AppConfigBase, EthereumStaticFeeConfig, BitcoinStaticFeeConfig {
}
type AppConfig = AppConfigWithFullStaticFees | AppConfigWithFullDynamicFees | AppConfigWithDynamicFeesForEthereum | AppConfigWithDynamicFeesForBitcoin;
type CriticalConfig = Pick<AppConfig, 'critical' | 'criticalBitcoin'>;
type NonCriticalConfig = Pick<AppConfig, 'nonCritical' | 'nonCriticalBitcoin'>;
type BridgeConfig = {
    config?: AppConfig;
    error?: any;
};
declare enum AssetType {
    NATIVE = 0,
    ERC20 = 1,
    BTC = 2
}
interface Assets {
    [symbol: string]: Asset;
}
type EthereumStaticFeeConfigAssets = Record<string, EthereumStaticFeeAssetConfig>;
type EthereumDynamicFeeConfigAssets = Record<string, EthereumDynamicFeeAssetConfig>;
type EthereumConfigAssets = EthereumStaticFeeConfigAssets | EthereumDynamicFeeConfigAssets;
interface BitcoinStaticFeeConfigAsset extends BitcoinConfigAsset {
    offboardFeeDollars: number;
    onboardFeeDollars: number;
}
interface BitcoinDynamicFeeConfigAsset extends BitcoinConfigAsset {
    offboardFeeConfiguration: DynamicFeeConfiguration;
    onboardFeeConfiguration: DynamicFeeConfiguration;
}
type BitcoinStaticFeeConfigAssets = Record<string, BitcoinStaticFeeConfigAsset>;
type BitcoinDynamicFeeConfigAssets = Record<string, BitcoinDynamicFeeConfigAsset>;
type BitcoinConfigAssets = BitcoinStaticFeeConfigAssets | BitcoinDynamicFeeConfigAssets;
/**
 * Bridge assets can fall into one of these categories
 */
type Asset = EthereumConfigAsset | NativeAsset | BitcoinConfigAsset;
/**
 * Must exist on every asset.
 * This data is added to the raw config when it is fetched.
 */
interface AssetBase {
    symbol: string;
    tokenName: string;
    assetType: AssetType;
    nativeNetwork: Blockchain;
    denomination: number;
}
type DynamicFeeConfiguration = {
    feePercentage: number;
    feePercentageDecimals: number;
    maximumFeeDollars: number;
    minimumFeeDollars: number;
};
type DynamicFeeEstimation = {
    minimumFeeAmount: string;
    maximumFeeAmount: string;
    feePercentage: number;
    feePercentageDecimals: number;
};
interface EthereumAssetConfigBase extends AssetBase {
    avaxPromotionDollarThreshold: number;
    avaxPromotionAmount: string;
    chainlinkFeedAddress?: string;
    chainlinkFeedNetwork?: string;
    ipfsHash?: string;
    transferGasLimit?: number;
    nativeContractAddress: string;
    wrappedContractAddress: string;
    wrappedNetwork: string;
    deprecatedTokenContractAddress?: string;
    offboardFeeProcessThreshold: string;
}
interface EthereumStaticFeeAssetConfig extends EthereumAssetConfigBase {
    maximumOnboardFee?: string;
    onboardFeeDollars?: number;
    offboardFeeDollars: number;
    onboardFeePercentage?: string;
}
interface EthereumDynamicFeeAssetConfig extends EthereumAssetConfigBase {
    offboardFeeConfiguration: DynamicFeeConfiguration;
    onboardFeeConfiguration: DynamicFeeConfiguration;
}
/**
 * For Ethereum <-> Avalanche assets
 */
type EthereumConfigAsset = EthereumStaticFeeAssetConfig | EthereumDynamicFeeAssetConfig;
/**
 * For Bitcoin <-> Avalanche assets
 */
interface BitcoinConfigAsset extends AssetBase {
    additionalTxFeeAmount: number;
    avaxPromotionAmount: string;
    avaxPromotionDollarThreshold: number;
    bech32AddressPrefix: string;
    operatorAddress: string;
    privateKeyPrefix: string;
    reserveBalanceHighWaterMark: number;
    reserveBalanceLowWaterMark: number;
    targetChangeAmount: number;
    wrappedContractAddress: string;
    wrappedNetwork: string;
}
/**
 * Currently used only for native Ethereum since it is not provided in the bridge config.
 */
interface NativeAsset extends AssetBase {
    assetType: AssetType.NATIVE;
    wrappedAssetSymbol: string;
    coingeckoId: string;
}
interface AddEthereumChainParameter {
    chainId: string;
    chainName: string;
    nativeCurrency: {
        name: string;
        symbol: string;
        decimals: number;
    };
    rpcUrls: string[];
    blockExplorerUrls?: string[];
    iconUrls?: string[];
}

interface TokenInfo {
    logo: string;
    coingeckoId: string;
}
type TokenInfoData = Record<string, TokenInfo>;

interface TransactionDetails {
    tokenSymbol: string;
    amount: Big;
}
type EthChains = Blockchain.ETHEREUM | Blockchain.AVALANCHE;
interface BridgeTransaction {
    /** C-chain address */
    addressC: string;
    /** C-chain derived BTC address */
    addressBTC: string;
    /** The amount requested by the user to transfer */
    amount: Big;
    /** Token being transferred */
    symbol: string;
    /**
     * The transaction was successfully created on the target blockchain and
     * bridging is finished.
     */
    complete: boolean;
    completedAt?: number;
    /** Set when there is an error with transaction tracking */
    error?: any;
    /** The network environment */
    environment: 'main' | 'test';
    sourceChain: Blockchain;
    /** When tracking the source confirmations started */
    sourceStartedAt: number;
    sourceTxHash: string;
    sourceNetworkFee?: Big;
    confirmationCount: number;
    requiredConfirmationCount: number;
    targetChain: Blockchain;
    /** When tracking the target transaction started */
    targetStartedAt?: number;
    targetTxHash?: string;
    /**
     * The fee paid to the bridge operators
     * (paid from the transferred asset e.g. LINK or WETH)
     */
    targetBridgeFee?: Big;
    /**
     * The fee paid to the blockchain
     * (paid in the native token e.g. ETH or AVAX)
     */
    targetNetworkFee?: Big;
    /** Block number used to find the target transaction hash */
    startBlockNumber?: number;
}
type TxHash = string;
declare enum WrapStatus {
    INITIAL = 0,
    WAITING_FOR_DEPOSIT_CONFIRMATION = 1,
    WAITING_FOR_DEPOSIT = 2,
    WAITING_FOR_CONFIRMATION = 3,
    COMPLETE = 4,
    VULNERABLE_ADDRESS = 5
}

type EthereumAssets = Record<string, NativeAsset | EthereumConfigAsset>;
type AvalancheAssets = Record<string, BitcoinConfigAsset | EthereumConfigAsset>;
interface BridgeSDKState {
    ethereumAssets: EthereumAssets;
    ethereumWrappedAssets: EthereumConfigAssets;
    avalancheAssets: AvalancheAssets;
    sourceAssets: Assets;
    bitcoinAssets: BitcoinConfigAssets;
    bridgeConfig: BridgeConfig;
    setBridgeConfig: (bridgeConfig: BridgeConfig) => void;
    criticalConfig?: CriticalConfig;
    currentBlockchain: Blockchain;
    setCurrentBlockchain: (blockchain: Blockchain) => void;
    targetBlockchain: Blockchain;
    currentAsset?: string;
    currentAssetData?: Asset;
    setCurrentAsset: (symbol: string) => void;
    transactionDetails?: TransactionDetails;
    setTransactionDetails: (transactionDetails: TransactionDetails) => void;
    targetChains: Blockchain[];
}

declare function useBridgeSDK(): BridgeSDKState;
declare function BridgeSDKProvider({ children }: {
    children: JSX.Element;
}): JSX.Element;

declare const initalState: {};
declare const TokenInfoProvider: ({ children }: {
    children: any;
}) => JSX.Element;
declare function useTokenInfoContext(): TokenInfoData | undefined;

/**
 * Get the bridge config from the bridge context. Use
 * useBridgeConfigUpdater() to ensure that the bridge config is
 * periodically re-fetch.
 *
 * @example
 * const { config, error } = useBridgeConfig();
 */
declare function useBridgeConfig(): BridgeConfig;

/**
 * Use to periodically re-fetch the bridge config. This is needed in case any of
 * the wardens returns disableFrontend === true which should shutdown the
 * frontend immediately.
 *
 * @param fetchFn use fetchConfig() by default, this param is provided so it can
 * be customized in the extension.
 *
 * @example
 * useBridgeConfigUpdater(() => fetchConfig("main"));
 */
declare function useBridgeConfigUpdater(fetchFn: () => Promise<BridgeConfig>): void;

declare function isBech32Address(btcAddress: string): boolean;
/**
 * In addition to Bech32 validation, it makes sure that the address is from the correct network.
 */
declare function isBech32AddressInNetwork(btcAddress: string, isMainnet: boolean): boolean;
/**
 * Verify if its a valid base 58 encoded address
 */
declare function isBase58Address(addr: string): boolean;
/**
 * Verify if address is valid base58 and matches the network
 * @param addr P2PKH or P2SH address to verify
 * @param isMainnet If true will verify it's a valid mainnet address
 */
declare function isBase58AddressInNetwork(addr: string, isMainnet: boolean): boolean;

type BtcBlockchains = Blockchain.AVALANCHE | Blockchain.BITCOIN;

/**
 * Return the estimated bridge fee that will be paid to the bridge operators.
 */
declare function getBridgeFeeEstimateBTC({ source, config, amount, }: {
    source: BtcBlockchains;
    config: AppConfig;
    amount: Big;
}): Big;
/**
 * Legacy (static) fee estimation for BTC
 */
declare function getStaticBridgeFeeEstimateBTC(source: BtcBlockchains, config: AppConfigWithStaticFeesForBitcoin, amountInSatoshis: number): Big;

/**
 * Get the BTC native asset on the bitcoin network.
 */
declare function getBtcAsset(config: CriticalConfig): BitcoinConfigAsset | undefined;

/**
 * Bitcoin to Avalanche
 * @param changeAddress: The user's C-chain derived BTC address. Change UTXO will be sent to this address.
 * @param config: Configuration file for the bridge.
 * @param utxos: The available UTXOs to consume.
 * @param amount: The amount to wrap in satoshis. Must cover the `bridgeFee`.
 * @param feeRate: Fee rate given in satoshis per byte.
 * @throws when the transaction cannot be created
 */
declare function getBtcTransaction(config: AppConfig, changeAddress: string, utxos: BitcoinInputUTXO[], amount: number, feeRate: number): {
    /** The total fee (bridge fee + tx fee) */
    fee: number;
    tx: Psbt;
    bridgeFee: number;
    receiveAmount: number;
    inputs: BitcoinInputUTXO[];
    outputs: BitcoinOutputUTXO[];
};

/**
 * Bitcoin to Avalanche
 * @param config: Configuration file for the bridge.
 * @param changeAddress: The user's C-chain derived BTC address. Change UTXO will be sent to this address.
 * @param utxos: The available UTXOs to consume.
 * @param amount: The amount to wrap in satoshis. Must cover the `bridgeFee`.
 * @param feeRate: Fee rate given in satoshis per byte.
 * @throws when the transaction is invalid
 */
declare function getBtcTransactionDetails(config: AppConfig, changeAddress: string, utxos: BitcoinInputUTXOWithOptionalScript[], amount: number, feeRate: number): {
    /** The total fee (bridge fee + tx fee) */
    fee: number;
    bridgeFee: number;
    receiveAmount: number;
    inputs: BitcoinInputUTXOWithOptionalScript[];
    outputs: BitcoinOutputUTXO[];
};

/**
 * Returns the minimum amount (in satoshis) can be sent to the bridge.
 * @param source
 * @param config
 * @param amount
 */
declare function getMinimumTransferAmount(source: BtcBlockchains, config: AppConfig, amount: number): number;

declare function getTxDetails(txHash: string, provider: BitcoinProvider): Promise<_avalabs_core_wallets_sdk.BitcoinTx>;
/**
 * Get the number of confirmations for a given transaction hash.
 * @param txHash
 * @param config
 */
declare function getTxConfirmations(txHash: string, provider: BitcoinProvider): Promise<number>;

declare function btcToSatoshi(btc: Big): number;
declare function satoshiToBtc(satoshis: number): Big;

type Args = {
    source: EthChains;
    config: AppConfig;
    asset: EthereumConfigAsset;
    amount: Big;
};
/**
 * Get Ethereum <-> Avalanche bridge fee estimate.
 */
declare function getBridgeFeeEstimateEVM({ source, config, asset, amount, }: Args): Big;
/**
 * Legacy (static) fee estimation for Ethereum
 */
declare function getStaticBridgeFeeEstimateEVM(source: EthChains, config: AppConfigWithStaticFeesForEthereum, asset: EthereumConfigAsset): Big;

interface HistoryTxData {
    transaction?: TransactionResponse;
    block?: Block | null;
    error?: string;
}
/**
 * EVM specific function to search for a new bridge transaction.
 */
declare function checkHistoryForNewTxEVM(network: Blockchain, provider: Provider, config: Maybe<AppConfig>, account: Maybe<string>, asset: Maybe<EthereumConfigAsset>, startBlockNumber: Maybe<number>): Promise<HistoryTxData | undefined>;

/**
 * Get the config for working with either mainnet or testnet blockchains.
 */
declare function fetchConfig(env?: Environment): Promise<BridgeConfig>;

/**
 * Fetch token balances for EVM
 */
declare function fetchTokenBalances(tokens: Record<string, Asset>, blockchain: Blockchain, provider: Provider, account: string, deprecated?: boolean): Promise<Record<string, Big>>;

/**
 * Return the assets available for the given chain
 * @param blockchain The blockchain to get asset dict for
 * @param config The config of the bridge
 */
declare function getAssets(blockchain: Blockchain.AVALANCHE, config: CriticalConfig): AvalancheAssets;
declare function getAssets(blockchain: Blockchain.BITCOIN, config: CriticalConfig): BitcoinConfigAssets;
declare function getAssets(blockchain: Blockchain.ETHEREUM, config: CriticalConfig): EthereumAssets;
declare function getAssets(blockchain: Blockchain, config: CriticalConfig): Assets;

type GetMaxTransferAmountParams = {
    currentBlockchain: Blockchain;
    currentAsset: string;
    balance: Big;
    assets: EthereumAssets | AvalancheAssets;
    provider: JsonRpcProvider;
    config: AppConfig;
};
declare function getMaxTransferAmount({ currentBlockchain, balance, currentAsset, assets, provider, config, }: GetMaxTransferAmountParams): Promise<Big | null>;

interface TrackerArgs {
    bridgeTransaction: BridgeTransaction;
    onBridgeTransactionUpdate: (bridgeTransaction: BridgeTransaction) => void;
    config: AppConfig;
    avalancheProvider: Provider;
    ethereumProvider: Provider;
    bitcoinProvider: BitcoinProvider;
}

interface TrackerSubscription {
    /** Cancel tracking */
    unsubscribe(): void;
    /** A flag to indicate whether this has already been unsubscribed */
    readonly closed: boolean;
}
/**
 * Track a bridge transaction to completion.
 *
 * The process consists of two steps:
 * - Ensure that the source blockchain has reached the required number of
 * confirmations.
 * - Watch for the new transaction to be created on the target blockchain.
 *
 * During the process `onBridgeTransactionUpdate` will be called when the state
 * of the `bridgeTransaction` changes e.g. `confirmationCount`
 *
 * When the two steps finish `onBridgeTransactionUpdate` will be called a final
 * time with `complete` set to true.
 *
 * @returns a subscription object that can be used to unsubscribe
 * (e.g. when used in a `useEffect` hook)
 */
declare function trackBridgeTransaction(args: TrackerArgs): TrackerSubscription;

type TransferAssetEVMParams = {
    currentBlockchain: Blockchain.AVALANCHE | Blockchain.ETHEREUM;
    amount: Big;
    account: string;
    asset: Asset;
    avalancheProvider: JsonRpcApiProvider;
    ethereumProvider: JsonRpcApiProvider;
    config: AppConfig;
    onStatusChange: (status: WrapStatus) => void;
    onTxHashChange: (txHash: string) => void;
    signAndSendEVM?: (txData: TransactionRequest) => Promise<TxHash>;
};
/**
 * Transfer an ERC20 asset.
 * When currentBlockchain is Avalanche the asset will be transferred to
 * Ethereum and vice versa.
 *
 * @param signAndSendEVM Required when the provider for the currentBlockchain
 * does not support signing transactions.
 */
declare function transferAssetEVM({ currentBlockchain, amount, account, asset, avalancheProvider, ethereumProvider, config, onStatusChange, onTxHashChange, signAndSendEVM, }: TransferAssetEVMParams): Promise<TxHash>;

type BtcTransactionRequest = [
    toAddress: string,
    amount: string,
    feeRate: number
];
type TransferAssetBTCParams = {
    amount: string;
    feeRate: number;
    config: AppConfig;
    onStatusChange: (status: WrapStatus) => void;
    onTxHashChange: (txHash: string) => void;
    signAndSendBTC: (txParams: BtcTransactionRequest) => Promise<TxHash>;
};
declare const transferAssetBTC: ({ amount, feeRate, config, onStatusChange, onTxHashChange, signAndSendBTC, }: TransferAssetBTCParams) => Promise<string>;

/**
 * Transfer from Avalanche to Ethereum or Bitcoin.
 */
declare function unwrapAsset(amount: Big, account: string, asset: EthereumConfigAsset | BitcoinConfigAsset, provider: JsonRpcApiProvider, onTxHashChange: (txHash: string) => void, signAndSendEVM?: (txData: TransactionRequest) => Promise<TxHash>): Promise<TxHash>;

/**
 * Transfer from Ethereum to Avalanche.
 *
 * @param wrappedAsset - must be provided when asset is of AssetType.NATIVE
 * @param signAndSendEVM - Optional, provide when NOT using Metamask. Some
 * providers like `InfuraProvider` don't support `getSigner` so
 * `signAndSendEVM` is used to manually sign and send the transaction instead of calling
 * `contract.transfer`.
 */
declare function wrapAsset(amount: Big, account: string, asset: EthereumConfigAsset | NativeAsset, avalancheProvider: JsonRpcApiProvider, ethereumProvider: JsonRpcApiProvider, config: AppConfig, onStatusChange: (status: WrapStatus) => void, onTxHashChange: (txHash: string) => void, signAndSendEVM?: (txData: TransactionRequest) => Promise<TxHash>): Promise<TxHash>;

declare function useCheckHistoryForNewTxEVM(network: Blockchain, provider: Provider, account: Maybe<string>, asset: Maybe<EthereumConfigAsset>): {
    checkHistoryForNewTx: () => Promise<HistoryTxData | undefined>;
    startBlockNumber: number | undefined;
};

declare function useGetAirdropAmount(sourceNetwork: Blockchain, assetPrice: Big, transactionDetails: Maybe<TransactionDetails>, assetInfo: Maybe<EthereumConfigAsset | BitcoinConfigAsset>): () => number;

/**
 * Fetch the account balance for the token on Ethereum or Avalanche.
 * @param blockchain network to get the balances on
 * @param asset the contract token (skips fetch when not defined)
 * @param deprecated query the deprecated token balance instead of the regular
 */
declare function useGetTokenBalanceEVM(blockchain: Blockchain.AVALANCHE | Blockchain.ETHEREUM, asset: Maybe<Asset>, provider: Provider, active: boolean, account: Maybe<string>, deprecated?: boolean): Big | undefined;

/**
 * Fetch the account balances for the tokens.
 * @param blockchain network to get the balances on
 * @param tokens the list of contract tokens
 * @param deprected query the deprecated token balance instead of the regular
 */
declare function useGetTokenBalancesEVM(blockchain: Blockchain, tokens: Maybe<Record<string, Asset>>, provider: Provider, active: boolean, account: Maybe<string>, deprecated?: boolean): {
    [key: string]: Big;
} | undefined;

declare function useGetTokenSymbolOnNetwork(): {
    getTokenSymbolOnNetwork: (symbol: string, network: Blockchain) => string;
};

declare function useHasEnoughForGas(account: Maybe<string>, provider: Maybe<Provider>): boolean;

declare function useIsAddressSanctioned(address: string): boolean;

/**
 * Calculates the approximate maximum abount transfarable for a given asset.
 * For ERC20s it's always the user's max balance
 * For native assets, since gas price is payed with the native asset,
 * it's balance minus approximate transaction fees
 */
declare function useMaxTransferAmount(balance: Maybe<Big>, account: Maybe<string>, provider: Maybe<JsonRpcProvider>): Big | null;

/**
 * Returns the price of the input currency (default is USD)
 * @param assetId id of the asset on coingecko, not matches the symbol
 * @param currency currency you want the result to be in, default is 'usd'
 */
declare function usePrice(assetId: string | undefined, currency?: VsCurrencyType): Big;

declare function usePriceForChain(chain: Blockchain | undefined): Big;

declare function useResetTransactionDetailsFromParams(avalancheProvider: Provider, ethereumProvider: Provider, setTransactionDetails: (details: TransactionDetails) => void, assets: Maybe<Assets>): (txHash: string, network: Blockchain) => Promise<void>;

declare function useSubscribeForNewTransactionFromBridgeEVM(network: Blockchain, avalancheProvider: Provider, ethereumProvider: Provider, config: Maybe<AppConfig>, asset: Maybe<EthereumConfigAsset>, account: Maybe<string>): TransactionResponse | undefined;

declare function useTimer(): {
    isActive: boolean;
    seconds: number;
    start: () => void;
    stop: () => void;
    setTimerSeconds: (startTimestamp: number, endTimestamp?: number) => void;
    started: number;
};

/**
 * Get the bridge fee depending on the selected chain and asset
 * @param amount
 */
declare function useBridgeFeeEstimate(amount: Big): Big | undefined;

/**
 * Transfer an ERC20 asset.
 * When currentBlockchain is Avalanche the asset will be transferred to
 * Ethereum and vice versa.
 *
 * @param signAndSendEVM Required when the provider for the currentBlockchain
 * @param avalancheProvider This can accept either a JsonRpcProvider or BrowserProvider.  If a signAndSendEVM param is provided, then this can be a JsonRpcProvider (i.e. a provider without signing capabilities), otherwise this should be a BrowserProvider, or other provider with signing capabilities (via the provider.getSigner method)
 * @param ethereumProvider Same comment as avalancheProvider^
 * does not support signing transactions.
 */
declare function useTransferAssetEVM(asset: Maybe<EthereumConfigAsset | NativeAsset>, account: Maybe<string>, avalancheProvider: JsonRpcApiProvider, ethereumProvider: JsonRpcApiProvider, signAndSendEVM?: (txData: TransactionRequest) => Promise<TxHash>): {
    transferAsset: (amount: Big) => Promise<string> | undefined;
    status: WrapStatus;
    txHash: string;
};

/**
 * Transfer Bitcoin asset to Avalanche.
 */
declare function useTransferAssetBTC(signAndSendBTC: (txParams: BtcTransactionRequest) => Promise<TxHash>): {
    transferAsset: (amount: string, feeRate: number) => Promise<string> | undefined;
    status: WrapStatus;
    txHash: string;
};

interface TrackerViewProps {
    sourceNetwork: Blockchain;
    sourceSeconds: number;
    sourceTxHash?: string;
    targetNetwork: Blockchain;
    targetSeconds: number;
    targetTxHash?: string;
    confirmationCount: number;
    requiredConfirmationCount: number;
    complete: boolean;
    gasCost?: Big;
    gasValue?: Big;
    amount?: Big;
    symbol?: string;
}
/**
 * @deprecated this hook is buggy, prefer trackBridgeTransaction instead.
 *
 * Track an EVM transaction
 * @param started Start timestamp of the source transaction.
 * @param isHidden Is the screen hidden e.g. document.hidden
 */
declare function useTxTracker(sourceNetwork: Blockchain, txId: string, started: string, avalancheProvider: Provider, ethereumProvider: Provider, setTransactionDetails: (details: TransactionDetails) => void, config: Maybe<AppConfig>, account: Maybe<string>, transactionDetails: Maybe<TransactionDetails>, ethWrappedAssets: Maybe<EthereumConfigAssets>, isHidden?: boolean): TrackerViewProps;

declare function useWaitForConfirmations(requiredConfirmationCount: number, provider: Provider, txHash: Maybe<string>): {
    confirmations: number;
    gasCost: Big | undefined;
};

/**
 * Get the bridge fee depending on the selected chain and asset
 * @param amount
 */
declare function useMinimumTransferAmount(amount: Big): Big;

declare const ETHERSCAN_API_KEY: string | undefined;
declare const INFURA_API_KEY: string | undefined;
/**
 * Set the bridge runtime environment.
 */
declare function setBridgeEnvironment(environment: Environment): void;
/**
 * Get the runtime config for the current environment.
 * @throws when the environment has not already been initialized by calling
 * `setBridgeEnvironment(env)`
 * @param env optional, provide to get the config for the given Environment.
 */
declare function getRuntimeConfig(env?: Environment): RuntimeConfig;

declare const BIG_TEN: Big;
declare const BIG_ZERO: Big;
declare const capped: (value: Big, { max, min }: {
    max: Big;
    min: Big;
}) => Big;

declare function isMainnetConfig(config: AppConfig): boolean;
/**
 * @returns the number of required confirmations before the bridge will initiate a transfer.
 */
declare function getMinimumConfirmations(blockchain: Blockchain, config: AppConfig): number;
/**
 * Compares critical sections of the bridge config.
 */
declare function hasCriticalChanges(oldConfig: BridgeConfig, newConfig: BridgeConfig): boolean;
declare function isEthUsingDynamicFees(config: AppConfig): config is AppConfigWithDynamicFeesForEthereum | AppConfigWithFullDynamicFees;
declare function isBtcUsingDynamicFees(config: AppConfig): config is AppConfigWithDynamicFeesForBitcoin | AppConfigWithFullDynamicFees;

declare function formatTokenAmount(amount: Big, denomination?: number): string;

declare function getNativeSymbol(chain: Blockchain): string;

declare const usdFormatter: Intl.NumberFormat;

declare const isAddressBlocklisted: ({ addressEVM, addressBTC, bridgeConfig, }: {
    addressEVM?: string | undefined;
    addressBTC?: string | undefined;
    bridgeConfig: BridgeConfig$1;
}) => boolean;

declare const isNativeAsset: (asset: Asset) => asset is NativeAsset;
declare const isBtcAsset: (asset: Asset) => asset is BitcoinConfigAsset;
declare const isEthAsset: (asset: Asset) => asset is EthereumConfigAsset;

declare const AVERAGE_TRANSFER_TX_GAS_USAGE = 40000n;
/**
 * NOTE: These estimates are only supposed to be used to approximate
 * the network fees in the UI.
 *
 * DO NOT use them as `gasLimit` prop on the transactions!
 */
declare function estimateGas(amount: Big, account: string, asset: Asset, providers: {
    ethereum: JsonRpcApiProvider;
    avalanche: JsonRpcApiProvider;
}, config: AppConfig, sourceBlockchain: Blockchain, withSigner?: boolean): Promise<bigint | undefined>;

export { AVERAGE_TRANSFER_TX_GAS_USAGE, AddEthereumChainParameter, AppConfig, AppConfigWithDynamicFeesForBitcoin, AppConfigWithDynamicFeesForEthereum, AppConfigWithFullDynamicFees, AppConfigWithFullStaticFees, AppConfigWithStaticFeesForBitcoin, AppConfigWithStaticFeesForEthereum, Asset, AssetBase, AssetType, Assets, AvalancheAssets, BIG_TEN, BIG_ZERO, BitcoinConfigAsset, BitcoinConfigAssets, BitcoinDynamicFeeConfig, BitcoinDynamicFeeConfigAsset, BitcoinDynamicFeeConfigAssets, BitcoinDynamicFeeCriticalConfig, BitcoinStaticFeeConfig, BitcoinStaticFeeConfigAsset, BitcoinStaticFeeConfigAssets, BitcoinStaticFeeCriticalConfig, Blockchain, BridgeConfig, BridgeSDKProvider, BridgeSDKState, BridgeTransaction, BtcBlockchains, BtcTransactionRequest, CriticalConfig, DynamicFeeEstimation, ETHERSCAN_API_KEY, Environment, EthChains, EthereumAssetConfigBase, EthereumAssets, EthereumConfigAsset, EthereumConfigAssets, EthereumDynamicFeeAssetConfig, EthereumDynamicFeeConfig, EthereumDynamicFeeConfigAssets, EthereumStaticFeeAssetConfig, EthereumStaticFeeConfig, EthereumStaticFeeConfigAssets, HistoryTxData, INFURA_API_KEY, NativeAsset, NetworkType, NonCriticalConfig, RuntimeConfig, TokenInfo, TokenInfoData, TokenInfoProvider, TrackerSubscription, TrackerViewProps, TransactionDetails, TransferAssetBTCParams, TransferAssetEVMParams, TxHash, WrapStatus, btcToSatoshi, capped, checkHistoryForNewTxEVM, estimateGas, fetchConfig, fetchTokenBalances, formatTokenAmount, getAssets, getBridgeFeeEstimateBTC, getBridgeFeeEstimateEVM, getBtcAsset, getBtcTransaction, getBtcTransactionDetails, getMaxTransferAmount, getMinimumConfirmations, getMinimumTransferAmount, getNativeSymbol, getRuntimeConfig, getStaticBridgeFeeEstimateBTC, getStaticBridgeFeeEstimateEVM, getTxConfirmations, getTxDetails, hasCriticalChanges, initalState, isAddressBlocklisted, isBase58Address, isBase58AddressInNetwork, isBech32Address, isBech32AddressInNetwork, isBtcAsset, isBtcUsingDynamicFees, isEthAsset, isEthUsingDynamicFees, isMainnetConfig, isNativeAsset, satoshiToBtc, setBridgeEnvironment, trackBridgeTransaction, transferAssetBTC, transferAssetEVM, unwrapAsset, usdFormatter, useBridgeConfig, useBridgeConfigUpdater, useBridgeFeeEstimate, useBridgeSDK, useCheckHistoryForNewTxEVM, useGetAirdropAmount, useGetTokenBalanceEVM, useGetTokenBalancesEVM, useGetTokenSymbolOnNetwork, useHasEnoughForGas, useIsAddressSanctioned, useMaxTransferAmount, useMinimumTransferAmount, usePrice, usePriceForChain, useResetTransactionDetailsFromParams, useSubscribeForNewTransactionFromBridgeEVM, useTimer, useTokenInfoContext, useTransferAssetBTC, useTransferAssetEVM, useTxTracker, useWaitForConfirmations, wrapAsset };