@hyperlane-xyz/sdk/dist/token/adapters/EvmTokenAdapter.d.ts

The official SDK for the Hyperlane Network

import { PopulatedTransaction } from 'ethers';
import { ERC20, HypERC20, HypERC20Collateral, HypERC4626, HypERC4626Collateral, HypERC4626OwnerCollateral, HypXERC20, HypXERC20Lockbox, IXERC20, IXERC20VS, MovableCollateralRouter, TokenRouter } from '@hyperlane-xyz/core';
import { Address, Domain, LazyAsync, Numberish } from '@hyperlane-xyz/utils';
import { BaseEvmAdapter } from '../../app/MultiProtocolApp.js';
import { EthJsonRpcBlockParameterTag } from '../../metadata/chainMetadataTypes.js';
import type { MultiProviderAdapter } from '../../providers/MultiProviderAdapter.js';
import { ChainName } from '../../types.js';
import { TokenMetadata } from '../types.js';
import { IHypCollateralFiatAdapter, IHypTokenAdapter, IHypVSXERC20Adapter, IHypXERC20Adapter, IMovableCollateralRouterAdapter, IPredicateAwareAdapter, ITokenAdapter, IXERC20Adapter, IXERC20VSAdapter, InterchainGasQuote, QuoteTransferRemoteParams, RateLimitMidPoint, TransferParams, TransferRemoteParams, xERC20Limits } from './ITokenAdapter.js';
export declare const EVM_TRANSFER_REMOTE_GAS_ESTIMATE = 450000n;
export declare class EvmNativeTokenAdapter extends BaseEvmAdapter implements ITokenAdapter<PopulatedTransaction> {
    getBalance(address: Address): Promise<bigint>;
    getMetadata(): Promise<TokenMetadata>;
    getMinimumTransferAmount(_recipient: Address): Promise<bigint>;
    isApproveRequired(_owner: Address, _spender: Address, _weiAmountOrId: Numberish): Promise<boolean>;
    isRevokeApprovalRequired(_owner: Address, _spender: Address): Promise<boolean>;
    populateApproveTx(_params: TransferParams): Promise<PopulatedTransaction>;
    populateTransferTx({ weiAmountOrId, recipient, }: TransferParams): Promise<PopulatedTransaction>;
    getTotalSupply(): Promise<bigint | undefined>;
}
export declare class EvmTokenAdapter<T extends ERC20 = ERC20> extends EvmNativeTokenAdapter implements ITokenAdapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    readonly contractFactory: any;
    readonly contract: T;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    }, contractFactory?: any);
    getBalance(address: Address): Promise<bigint>;
    getMetadata(isNft?: boolean): Promise<TokenMetadata>;
    isApproveRequired(owner: Address, spender: Address, weiAmountOrId: Numberish): Promise<boolean>;
    isRevokeApprovalRequired(owner: Address, spender: Address): Promise<boolean>;
    populateApproveTx({ weiAmountOrId, recipient, }: TransferParams): Promise<PopulatedTransaction>;
    populateTransferTx({ weiAmountOrId, recipient, }: TransferParams): Promise<PopulatedTransaction>;
    getTotalSupply(): Promise<bigint>;
}
export declare class EvmHypSyntheticAdapter extends EvmTokenAdapter<HypERC20> implements IHypTokenAdapter<PopulatedTransaction>, IPredicateAwareAdapter {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    readonly contractFactory: any;
    protected predicateWrapperAddress: Address | null | undefined;
    clearPredicateCache(): void;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    }, contractFactory?: any);
    isApproveRequired(owner: Address, spender: Address, weiAmountOrId: Numberish): Promise<boolean>;
    isRevokeApprovalRequired(owner: Address, spender: Address): Promise<boolean>;
    populateApproveTx(params: TransferParams): Promise<PopulatedTransaction>;
    getPredicateWrapperAddress(): Promise<Address | null>;
    private findPredicateWrapperInHook;
    getDomains(): Promise<Domain[]>;
    getRouterAddress(domain: Domain): Promise<Buffer>;
    getAllRouters(): Promise<Array<{
        domain: Domain;
        address: Buffer;
    }>>;
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint | undefined>;
    getContractPackageVersion(): Promise<string>;
    quoteTransferRemoteGas({ destination, recipient, amount, }: QuoteTransferRemoteParams): Promise<InterchainGasQuote>;
    /**
     * Check if this warp route supports Predicate attestations
     * @returns True if a PredicateRouterWrapper is configured on the hook
     */
    supportsAttestation(): Promise<boolean>;
    protected populatePredicateTransferRemoteTx(params: TransferRemoteParams, nativeValue: bigint): Promise<PopulatedTransaction>;
    populateTransferRemoteTx(params: TransferRemoteParams, nativeValue?: bigint): Promise<PopulatedTransaction>;
}
declare class BaseEvmHypCollateralAdapter extends EvmHypSyntheticAdapter implements IHypTokenAdapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    readonly collateralContract: TokenRouter;
    protected readonly wrappedTokenAddress: LazyAsync<string>;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    getWrappedTokenAddress(): Promise<Address>;
    protected loadWrappedTokenAddress(): Promise<Address>;
    protected getWrappedTokenAdapter(): Promise<EvmTokenAdapter>;
    getBalance(address: Address): Promise<bigint>;
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint | undefined>;
    getMetadata(isNft?: boolean): Promise<TokenMetadata>;
    isApproveRequired(owner: Address, spender: Address, weiAmountOrId: Numberish): Promise<boolean>;
    isRevokeApprovalRequired(owner: Address, spender: Address): Promise<boolean>;
    populateApproveTx(params: TransferParams): Promise<PopulatedTransaction>;
    /**
     * Check if this warp route supports Predicate attestations
     * @returns True if a PredicateRouterWrapper is configured on the hook
     */
    supportsAttestation(): Promise<boolean>;
    populateTransferRemoteTx(params: TransferRemoteParams, nativeValue?: bigint): Promise<PopulatedTransaction>;
    populateTransferTx(params: TransferParams): Promise<PopulatedTransaction>;
}
export declare class EvmHypCollateralAdapter extends BaseEvmHypCollateralAdapter implements IHypTokenAdapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    readonly collateralContract: HypERC20Collateral;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    protected loadWrappedTokenAddress(): Promise<Address>;
}
export declare class EvmMovableCollateralAdapter extends EvmHypCollateralAdapter implements IMovableCollateralRouterAdapter<PopulatedTransaction> {
    movableCollateral(): MovableCollateralRouter;
    isRebalancer(account: Address): Promise<boolean>;
    getAllowedDestination(domain: Domain): Promise<Address>;
    isBridgeAllowed(domain: Domain, bridge: Address): Promise<boolean>;
    getRebalanceQuotes(bridge: Address, domain: Domain, recipient: Address, amount: Numberish): Promise<InterchainGasQuote[]>;
    /**
     * @param quotes - The quotes returned by getRebalanceQuotes
     */
    populateRebalanceTx(domain: Domain, amount: Numberish, bridge: Address, quotes: InterchainGasQuote[]): Promise<PopulatedTransaction>;
}
export declare class EvmHypCollateralFiatAdapter extends EvmHypCollateralAdapter implements IHypCollateralFiatAdapter<PopulatedTransaction> {
    /**
     * Note this may be inaccurate, as this returns the total supply
     * of the fiat token, which may be used by other bridges.
     * However this is the best we can do with a simple view call.
     */
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint>;
    getMintLimit(): Promise<bigint>;
}
export declare class EvmHypRebaseCollateralAdapter extends BaseEvmHypCollateralAdapter implements IHypTokenAdapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    collateralContract: HypERC4626Collateral;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    protected loadWrappedTokenAddress(): Promise<Address>;
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint>;
}
export declare class EvmHypOwnerCollateralAdapter extends EvmHypRebaseCollateralAdapter implements IHypTokenAdapter<PopulatedTransaction> {
    collateralContract: HypERC4626OwnerCollateral;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint>;
}
export declare class EvmHypSyntheticRebaseAdapter extends EvmHypSyntheticAdapter implements IHypTokenAdapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    contract: HypERC4626;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint>;
}
declare abstract class BaseEvmHypXERC20Adapter<X extends IXERC20 | IXERC20VS> extends EvmHypCollateralAdapter implements IHypXERC20Adapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    readonly hypXERC20: HypXERC20;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    protected abstract connectXERC20(xerc20Addr: Address): X;
    getXERC20(): Promise<X>;
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint>;
    getMintLimit(): Promise<bigint>;
    getMintMaxLimit(): Promise<bigint>;
    getBurnLimit(): Promise<bigint>;
    getBurnMaxLimit(): Promise<bigint>;
}
declare abstract class BaseEvmHypXERC20LockboxAdapter<X extends IXERC20 | IXERC20VS> extends EvmHypCollateralAdapter implements IHypXERC20Adapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    protected readonly hypXERC20Lockbox: HypXERC20Lockbox;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    protected loadWrappedTokenAddress(): Promise<Address>;
    /**
     * Note this may be inaccurate, as this returns the balance
     * of the lockbox contract, which may be used by other bridges.
     * However this is the best we can do with a simple view call.
     */
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint>;
    getXERC20(): Promise<X>;
    protected abstract connectXERC20(xERC20Addr: Address): X;
    getMintLimit(): Promise<bigint>;
    getMintMaxLimit(): Promise<bigint>;
    getBurnLimit(): Promise<bigint>;
    getBurnMaxLimit(): Promise<bigint>;
}
export declare class EvmHypXERC20LockboxAdapter extends BaseEvmHypXERC20LockboxAdapter<IXERC20> {
    protected connectXERC20(xERC20Addr: Address): IXERC20;
}
export declare class EvmHypVSXERC20LockboxAdapter extends BaseEvmHypXERC20LockboxAdapter<IXERC20VS> implements IHypVSXERC20Adapter<PopulatedTransaction> {
    protected connectXERC20(xERC20Addr: Address): IXERC20VS;
    getRateLimits(): Promise<RateLimitMidPoint>;
    populateSetBufferCapTx(newBufferCap: bigint): Promise<PopulatedTransaction>;
    populateSetRateLimitPerSecondTx(newRateLimitPerSecond: bigint): Promise<PopulatedTransaction>;
    populateAddBridgeTx(bufferCap: bigint, rateLimitPerSecond: bigint): Promise<PopulatedTransaction>;
}
export declare class EvmHypXERC20Adapter extends BaseEvmHypXERC20Adapter<IXERC20> {
    protected connectXERC20(xerc20Addr: string): IXERC20;
}
export declare class EvmHypVSXERC20Adapter extends BaseEvmHypXERC20Adapter<IXERC20VS> implements IHypVSXERC20Adapter<PopulatedTransaction> {
    protected connectXERC20(xerc20Addr: string): IXERC20VS;
    getRateLimits(): Promise<RateLimitMidPoint>;
    populateSetBufferCapTx(newBufferCap: bigint): Promise<PopulatedTransaction>;
    populateSetRateLimitPerSecondTx(newRateLimitPerSecond: bigint): Promise<PopulatedTransaction>;
    populateAddBridgeTx(bufferCap: bigint, rateLimitPerSecond: bigint): Promise<PopulatedTransaction>;
}
export declare class EvmHypNativeAdapter extends EvmMovableCollateralAdapter implements IHypTokenAdapter<PopulatedTransaction> {
    getBalance(address: Address): Promise<bigint>;
    isApproveRequired(): Promise<boolean>;
    isRevokeApprovalRequired(_owner: Address, _spender: Address): Promise<boolean>;
    /**
     * @param quotes - The quotes returned by getRebalanceQuotes
     */
    populateRebalanceTx(domain: Domain, amount: Numberish, bridge: Address, quotes: InterchainGasQuote[]): Promise<PopulatedTransaction>;
    populateTransferRemoteTx({ weiAmountOrId, destination, recipient, interchainGas, attestation, }: TransferRemoteParams): Promise<PopulatedTransaction>;
    getBridgedSupply(options?: {
        blockTag?: number | EthJsonRpcBlockParameterTag;
    }): Promise<bigint | undefined>;
}
export declare class EvmXERC20Adapter extends EvmTokenAdapter implements IXERC20Adapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    xERC20: IXERC20;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    getLimits(bridge: Address): Promise<xERC20Limits>;
    populateSetLimitsTx(bridge: Address, mint: bigint, burn: bigint): Promise<PopulatedTransaction>;
}
export declare class EvmXERC20VSAdapter extends EvmTokenAdapter implements IXERC20VSAdapter<PopulatedTransaction> {
    readonly chainName: ChainName;
    readonly multiProvider: MultiProviderAdapter;
    readonly addresses: {
        token: Address;
    };
    xERC20VS: IXERC20VS;
    constructor(chainName: ChainName, multiProvider: MultiProviderAdapter, addresses: {
        token: Address;
    });
    getRateLimits(bridge: Address): Promise<RateLimitMidPoint>;
    populateRemoveBridgeTx(bridge: Address): Promise<PopulatedTransaction>;
    populateSetBufferCapTx(bridge: Address, newBufferCap: bigint): Promise<PopulatedTransaction>;
    populateSetRateLimitPerSecondTx(bridge: Address, newRateLimitPerSecond: bigint): Promise<PopulatedTransaction>;
    populateAddBridgeTx(bufferCap: bigint, rateLimitPerSecond: bigint, bridge: Address): Promise<PopulatedTransaction>;
}
export {};
//# sourceMappingURL=EvmTokenAdapter.d.ts.map