## API Report File for "@mahadao/arth-ethers"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { ARTHReceipt } from '@mahadao/arth-base';
import { ARTHStore } from '@mahadao/arth-base';
import { ARTHStoreState } from '@mahadao/arth-base';
import { BigNumberish } from '@ethersproject/bignumber';
import { BlockTag } from '@ethersproject/abstract-provider';
import { CollateralGainTransferDetails } from '@mahadao/arth-base';
import { Decimal } from '@mahadao/arth-base';
import { Decimalish } from '@mahadao/arth-base';
import { ErrorCode } from '@ethersproject/logger';
import { FailedReceipt } from '@mahadao/arth-base';
import { Fees } from '@mahadao/arth-base';
import { FrontendStatus } from '@mahadao/arth-base';
import { LiquidationDetails } from '@mahadao/arth-base';
import { MinedReceipt } from '@mahadao/arth-base';
import { ObservableARTH } from '@mahadao/arth-base';
import { PopulatableARTH } from '@mahadao/arth-base';
import { PopulatedARTHTransaction } from '@mahadao/arth-base';
import { PopulatedRedemption } from '@mahadao/arth-base';
import { PopulatedTransaction } from '@ethersproject/contracts';
import { Provider } from '@ethersproject/abstract-provider';
import { ReadableARTH } from '@mahadao/arth-base';
import { RedemptionDetails } from '@mahadao/arth-base';
import { SendableARTH } from '@mahadao/arth-base';
import { SentARTHTransaction } from '@mahadao/arth-base';
import { Signer } from '@ethersproject/abstract-signer';
import { StabilityDeposit } from '@mahadao/arth-base';
import { StabilityDepositChangeDetails } from '@mahadao/arth-base';
import { StabilityPoolGainsWithdrawalDetails } from '@mahadao/arth-base';
import { TransactableARTH } from '@mahadao/arth-base';
import { TransactionFailedError } from '@mahadao/arth-base';
import { TransactionReceipt } from '@ethersproject/abstract-provider';
import { TransactionResponse } from '@ethersproject/abstract-provider';
import { Trove } from '@mahadao/arth-base';
import { TroveAdjustmentDetails } from '@mahadao/arth-base';
import { TroveAdjustmentParams } from '@mahadao/arth-base';
import { TroveClosureDetails } from '@mahadao/arth-base';
import { TroveCreationDetails } from '@mahadao/arth-base';
import { TroveCreationParams } from '@mahadao/arth-base';
import { TroveListingParams } from '@mahadao/arth-base';
import { TroveWithPendingRedistribution } from '@mahadao/arth-base';
import { UserTrove } from '@mahadao/arth-base';

// @public
export class BlockPolledARTHStore extends ARTHStore<BlockPolledARTHStoreExtraState> {
    constructor(readable: ReadableEthersARTH);
    // (undocumented)
    readonly connection: EthersARTHConnection;
    // @internal @override (undocumented)
    protected _doStart(): () => void;
    // @internal @override (undocumented)
    protected _reduceExtra(oldState: BlockPolledARTHStoreExtraState, stateUpdate: Partial<BlockPolledARTHStoreExtraState>): BlockPolledARTHStoreExtraState;
}

// @public
export interface BlockPolledARTHStoreExtraState {
    blockTag?: number;
    blockTimestamp: number;
    // @internal (undocumented)
    _feesFactory: (blockTimestamp: number, recoveryMode: boolean) => Fees;
}

// @public
export type BlockPolledARTHStoreState = ARTHStoreState<BlockPolledARTHStoreExtraState>;

// @public
export interface BorrowingOperationOptionalParams {
    borrowingFeeDecayToleranceMinutes?: number;
    maxBorrowingRate?: Decimalish;
}

// @internal (undocumented)
export function _connectByChainId<T>(provider: EthersProvider, signer: EthersSigner | undefined, chainId: number, optionalParams: EthersARTHConnectionOptionalParams & {
    useStore: T;
}): EthersARTHConnection & {
    useStore: T;
};

// @internal (undocumented)
export function _connectByChainId(provider: EthersProvider, signer: EthersSigner | undefined, chainId: number, optionalParams?: EthersARTHConnectionOptionalParams): EthersARTHConnection;

// @public
export class EthersARTH implements ReadableEthersARTH, TransactableARTH {
    // @internal
    constructor(readable: ReadableEthersARTH);
    // (undocumented)
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRateOrOptionalParams?: Decimalish | BorrowingOperationOptionalParams, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    borrowARTH(amount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    claimCollateralSurplus(overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    closeTrove(overrides?: EthersTransactionOverrides): Promise<TroveClosureDetails>;
    // @internal (undocumented)
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams: EthersARTHConnectionOptionalParams & {
        useStore: "blockPolled";
    }): Promise<EthersARTHWithStore<BlockPolledARTHStore>>;
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams?: EthersARTHConnectionOptionalParams): Promise<EthersARTH>;
    readonly connection: EthersARTHConnection;
    // (undocumented)
    depositARTHInStabilityPool(amount: Decimalish, frontendTag?: string, overrides?: EthersTransactionOverrides): Promise<StabilityDepositChangeDetails>;
    // (undocumented)
    depositCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // @internal (undocumented)
    static _from(connection: EthersARTHConnection & {
        useStore: "blockPolled";
    }): EthersARTHWithStore<BlockPolledARTHStore>;
    // @internal (undocumented)
    static _from(connection: EthersARTHConnection): EthersARTH;
    // @internal (undocumented)
    _getActivePool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getARTHBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getARTHInStabilityPool(overrides?: EthersCallOverrides): Promise<Decimal>;
    // @internal (undocumented)
    _getBlockTimestamp(blockTag?: BlockTag): Promise<number>;
    // (undocumented)
    getCollateralSurplusBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // @internal (undocumented)
    _getDefaultPool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getFees(overrides?: EthersCallOverrides): Promise<Fees>;
    // @internal (undocumented)
    _getFeesFactory(overrides?: EthersCallOverrides): Promise<(blockTimestamp: number, recoveryMode: boolean) => Fees>;
    // (undocumented)
    getFrontendStatus(address?: string, overrides?: EthersCallOverrides): Promise<FrontendStatus>;
    // (undocumented)
    getMAHABalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getNumberOfTroves(overrides?: EthersCallOverrides): Promise<number>;
    // (undocumented)
    getPrice(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getRemainingStabilityPoolMAHAReward(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getStabilityDeposit(address?: string, overrides?: EthersCallOverrides): Promise<StabilityDeposit>;
    // (undocumented)
    getTotal(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTotalRedistributed(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTrove(address?: string, overrides?: EthersCallOverrides): Promise<UserTrove>;
    // (undocumented)
    getTroveBeforeRedistribution(address?: string, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution>;
    // @internal (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution[]>;
    // (undocumented)
    getTroves(params: TroveListingParams, overrides?: EthersCallOverrides): Promise<UserTrove[]>;
    hasStore(): this is EthersARTHWithStore;
    hasStore(store: "blockPolled"): this is EthersARTHWithStore<BlockPolledARTHStore>;
    // (undocumented)
    liquidate(address: string | string[], overrides?: EthersTransactionOverrides): Promise<LiquidationDetails>;
    // (undocumented)
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number, overrides?: EthersTransactionOverrides): Promise<LiquidationDetails>;
    // (undocumented)
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRateOrOptionalParams?: Decimalish | BorrowingOperationOptionalParams, overrides?: EthersTransactionOverrides): Promise<TroveCreationDetails>;
    readonly populate: PopulatableEthersARTH;
    // (undocumented)
    redeemARTH(amount: Decimalish, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<RedemptionDetails>;
    // (undocumented)
    registerFrontend(kickbackRate: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    repayARTH(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    readonly send: SendableEthersARTH;
    // (undocumented)
    sendARTH(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    sendMAHA(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // @internal (undocumented)
    setPrice(price: Decimalish, overrides?: EthersTransactionOverrides): Promise<void>;
    // (undocumented)
    transferCollateralGainToTrove(overrides?: EthersTransactionOverrides): Promise<CollateralGainTransferDetails>;
    // (undocumented)
    withdrawARTHFromStabilityPool(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<StabilityDepositChangeDetails>;
    // (undocumented)
    withdrawCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<TroveAdjustmentDetails>;
    // (undocumented)
    withdrawGainsFromStabilityPool(overrides?: EthersTransactionOverrides): Promise<StabilityPoolGainsWithdrawalDetails>;
}

// @public
export interface EthersARTHConnection extends EthersARTHConnectionOptionalParams {
    // @internal (undocumented)
    readonly [brand]: unique symbol;
    readonly addresses: Record<string, string>;
    readonly bootstrapPeriod: number;
    readonly chainId: number;
    readonly deploymentDate: Date;
    // @internal (undocumented)
    readonly _isDev: boolean;
    // @internal (undocumented)
    readonly _priceFeedIsTestnet: boolean;
    readonly provider: EthersProvider;
    readonly signer?: EthersSigner;
    readonly startBlock: number;
    readonly totalStabilityPoolMAHAReward: Decimal;
    readonly version: string;
}

// @public
export interface EthersARTHConnectionOptionalParams {
    readonly frontendTag?: string;
    readonly userAddress?: string;
    readonly useStore?: EthersARTHStoreOption;
}

// @public
export type EthersARTHStoreOption = "blockPolled";

// @public
export interface EthersARTHWithStore<T extends ARTHStore = ARTHStore> extends EthersARTH {
    readonly store: T;
}

// @public
export interface EthersCallOverrides {
    // (undocumented)
    blockTag?: BlockTag;
}

// @public
export type EthersPopulatedTransaction = PopulatedTransaction;

// @public
export type EthersProvider = Provider;

// @public
export type EthersSigner = Signer;

// @public
export class EthersTransactionCancelledError extends Error {
    // @internal
    constructor(rawError: _RawTransactionReplacedError);
    // (undocumented)
    readonly rawError: Error;
    // (undocumented)
    readonly rawReplacementReceipt: EthersTransactionReceipt;
}

// @public
export class EthersTransactionFailedError extends TransactionFailedError<FailedReceipt<EthersTransactionReceipt>> {
    constructor(message: string, failedReceipt: FailedReceipt<EthersTransactionReceipt>);
}

// @public
export interface EthersTransactionOverrides {
    // (undocumented)
    from?: string;
    // (undocumented)
    gasLimit?: BigNumberish;
    // (undocumented)
    gasPrice?: BigNumberish;
    // (undocumented)
    nonce?: BigNumberish;
}

// @public
export type EthersTransactionReceipt = TransactionReceipt;

// @public
export type EthersTransactionResponse = TransactionResponse;

// @alpha (undocumented)
export class ObservableEthersARTH implements ObservableARTH {
    constructor(readable: ReadableEthersARTH);
    // (undocumented)
    watchARTHBalance(onARTHBalanceChanged: (balance: Decimal) => void, address?: string): () => void;
    // (undocumented)
    watchARTHInStabilityPool(onARTHInStabilityPoolChanged: (arthInStabilityPool: Decimal) => void): () => void;
    // (undocumented)
    watchNumberOfTroves(onNumberOfTrovesChanged: (numberOfTroves: number) => void): () => void;
    // (undocumented)
    watchPrice(onPriceChanged: (price: Decimal) => void): () => void;
    // (undocumented)
    watchStabilityDeposit(onStabilityDepositChanged: (stabilityDeposit: StabilityDeposit) => void, address?: string): () => void;
    // (undocumented)
    watchTotal(onTotalChanged: (total: Trove) => void): () => void;
    // (undocumented)
    watchTotalRedistributed(onTotalRedistributedChanged: (totalRedistributed: Trove) => void): () => void;
    // (undocumented)
    watchTroveWithoutRewards(onTroveChanged: (trove: TroveWithPendingRedistribution) => void, address?: string): () => void;
}

// @public
export class PopulatableEthersARTH implements PopulatableARTH<EthersTransactionReceipt, EthersTransactionResponse, EthersPopulatedTransaction> {
    constructor(readable: ReadableEthersARTH);
    // (undocumented)
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRateOrOptionalParams?: Decimalish | BorrowingOperationOptionalParams, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    borrowARTH(amount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    claimCollateralSurplus(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<void>>;
    // (undocumented)
    closeTrove(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveClosureDetails>>;
    // (undocumented)
    depositARTHInStabilityPool(amount: Decimalish, frontendTag?: string, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<StabilityDepositChangeDetails>>;
    // (undocumented)
    depositCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    liquidate(address: string | string[], overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<LiquidationDetails>>;
    // (undocumented)
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<LiquidationDetails>>;
    // (undocumented)
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRateOrOptionalParams?: Decimalish | BorrowingOperationOptionalParams, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveCreationDetails>>;
    // (undocumented)
    redeemARTH(amount: Decimalish, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersRedemption>;
    // (undocumented)
    registerFrontend(kickbackRate: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<void>>;
    // (undocumented)
    repayARTH(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    sendARTH(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<void>>;
    // (undocumented)
    sendMAHA(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<void>>;
    // @internal (undocumented)
    setPrice(price: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<void>>;
    // (undocumented)
    transferCollateralGainToTrove(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<CollateralGainTransferDetails>>;
    // (undocumented)
    withdrawARTHFromStabilityPool(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<StabilityDepositChangeDetails>>;
    // (undocumented)
    withdrawCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    withdrawGainsFromStabilityPool(overrides?: EthersTransactionOverrides): Promise<PopulatedEthersARTHTransaction<StabilityPoolGainsWithdrawalDetails>>;
    }

// @public
export class PopulatedEthersARTHTransaction<T = unknown> implements PopulatedARTHTransaction<EthersPopulatedTransaction, SentEthersARTHTransaction<T>> {
    // @internal
    constructor(rawPopulatedTransaction: EthersPopulatedTransaction, connection: EthersARTHConnection, parse: (rawReceipt: EthersTransactionReceipt) => T, gasHeadroom?: number);
    readonly gasHeadroom?: number;
    readonly rawPopulatedTransaction: EthersPopulatedTransaction;
    // (undocumented)
    send(): Promise<SentEthersARTHTransaction<T>>;
}

// @public (undocumented)
export class PopulatedEthersRedemption extends PopulatedEthersARTHTransaction<RedemptionDetails> implements PopulatedRedemption<EthersPopulatedTransaction, EthersTransactionResponse, EthersTransactionReceipt> {
    // @internal
    constructor(rawPopulatedTransaction: EthersPopulatedTransaction, connection: EthersARTHConnection, attemptedARTHAmount: Decimal, redeemableARTHAmount: Decimal, increaseAmountByMinimumNetDebt?: (maxRedemptionRate?: Decimalish) => Promise<PopulatedEthersRedemption>);
    // (undocumented)
    readonly attemptedARTHAmount: Decimal;
    // (undocumented)
    increaseAmountByMinimumNetDebt(maxRedemptionRate?: Decimalish): Promise<PopulatedEthersRedemption>;
    // (undocumented)
    readonly isTruncated: boolean;
    // (undocumented)
    readonly redeemableARTHAmount: Decimal;
}

// @internal (undocumented)
export enum _RawErrorReason {
    // (undocumented)
    TRANSACTION_CANCELLED = "cancelled",
    // (undocumented)
    TRANSACTION_FAILED = "transaction failed",
    // (undocumented)
    TRANSACTION_REPLACED = "replaced",
    // (undocumented)
    TRANSACTION_REPRICED = "repriced"
}

// @internal (undocumented)
export interface _RawTransactionReplacedError extends Error {
    // (undocumented)
    cancelled: boolean;
    // (undocumented)
    code: ErrorCode.TRANSACTION_REPLACED;
    // (undocumented)
    hash: string;
    // (undocumented)
    reason: _RawErrorReason.TRANSACTION_CANCELLED | _RawErrorReason.TRANSACTION_REPLACED | _RawErrorReason.TRANSACTION_REPRICED;
    // (undocumented)
    receipt: EthersTransactionReceipt;
    // (undocumented)
    replacement: EthersTransactionResponse;
}

// @public
export class ReadableEthersARTH implements ReadableARTH {
    // @internal
    constructor(connection: EthersARTHConnection);
    // @internal (undocumented)
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams: EthersARTHConnectionOptionalParams & {
        useStore: "blockPolled";
    }): Promise<ReadableEthersARTHWithStore<BlockPolledARTHStore>>;
    // (undocumented)
    static connect(signerOrProvider: EthersSigner | EthersProvider, optionalParams?: EthersARTHConnectionOptionalParams): Promise<ReadableEthersARTH>;
    // (undocumented)
    readonly connection: EthersARTHConnection;
    // @internal (undocumented)
    static _from(connection: EthersARTHConnection & {
        useStore: "blockPolled";
    }): ReadableEthersARTHWithStore<BlockPolledARTHStore>;
    // @internal (undocumented)
    static _from(connection: EthersARTHConnection): ReadableEthersARTH;
    // @internal (undocumented)
    _getActivePool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getARTHBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getARTHInStabilityPool(overrides?: EthersCallOverrides): Promise<Decimal>;
    // @internal (undocumented)
    _getBlockTimestamp(blockTag?: BlockTag): Promise<number>;
    // (undocumented)
    getCollateralSurplusBalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // @internal (undocumented)
    _getDefaultPool(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getFees(overrides?: EthersCallOverrides): Promise<Fees>;
    // @internal (undocumented)
    _getFeesFactory(overrides?: EthersCallOverrides): Promise<(blockTimestamp: number, recoveryMode: boolean) => Fees>;
    // (undocumented)
    getFrontendStatus(address?: string, overrides?: EthersCallOverrides): Promise<FrontendStatus>;
    // (undocumented)
    getMAHABalance(address?: string, overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getNumberOfTroves(overrides?: EthersCallOverrides): Promise<number>;
    // (undocumented)
    getPrice(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getRemainingStabilityPoolMAHAReward(overrides?: EthersCallOverrides): Promise<Decimal>;
    // (undocumented)
    getStabilityDeposit(address?: string, overrides?: EthersCallOverrides): Promise<StabilityDeposit>;
    // (undocumented)
    getTotal(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTotalRedistributed(overrides?: EthersCallOverrides): Promise<Trove>;
    // (undocumented)
    getTrove(address?: string, overrides?: EthersCallOverrides): Promise<UserTrove>;
    // (undocumented)
    getTroveBeforeRedistribution(address?: string, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution>;
    // @internal (undocumented)
    getTroves(params: TroveListingParams & {
        beforeRedistribution: true;
    }, overrides?: EthersCallOverrides): Promise<TroveWithPendingRedistribution[]>;
    // (undocumented)
    getTroves(params: TroveListingParams, overrides?: EthersCallOverrides): Promise<UserTrove[]>;
    hasStore(): this is ReadableEthersARTHWithStore;
    hasStore(store: "blockPolled"): this is ReadableEthersARTHWithStore<BlockPolledARTHStore>;
}

// @public
export interface ReadableEthersARTHWithStore<T extends ARTHStore = ARTHStore> extends ReadableEthersARTH {
    readonly store: T;
}

// @internal (undocumented)
export const _redeemMaxIterations = 70;

// @public
export class SendableEthersARTH implements SendableARTH<EthersTransactionReceipt, EthersTransactionResponse> {
    constructor(populatable: PopulatableEthersARTH);
    // (undocumented)
    adjustTrove(params: TroveAdjustmentParams<Decimalish>, maxBorrowingRateOrOptionalParams?: Decimalish | BorrowingOperationOptionalParams, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    borrowARTH(amount: Decimalish, maxBorrowingRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    claimCollateralSurplus(overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<void>>;
    // (undocumented)
    closeTrove(overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveClosureDetails>>;
    // (undocumented)
    depositARTHInStabilityPool(amount: Decimalish, frontendTag?: string, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<StabilityDepositChangeDetails>>;
    // (undocumented)
    depositCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    liquidate(address: string | string[], overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<LiquidationDetails>>;
    // (undocumented)
    liquidateUpTo(maximumNumberOfTrovesToLiquidate: number, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<LiquidationDetails>>;
    // (undocumented)
    openTrove(params: TroveCreationParams<Decimalish>, maxBorrowingRateOrOptionalParams?: Decimalish | BorrowingOperationOptionalParams, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveCreationDetails>>;
    // (undocumented)
    redeemARTH(amount: Decimalish, maxRedemptionRate?: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<RedemptionDetails>>;
    // (undocumented)
    registerFrontend(kickbackRate: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<void>>;
    // (undocumented)
    repayARTH(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    sendARTH(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<void>>;
    // (undocumented)
    sendMAHA(toAddress: string, amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<void>>;
    // @internal (undocumented)
    setPrice(price: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<void>>;
    // (undocumented)
    transferCollateralGainToTrove(overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<CollateralGainTransferDetails>>;
    // (undocumented)
    withdrawARTHFromStabilityPool(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<StabilityDepositChangeDetails>>;
    // (undocumented)
    withdrawCollateral(amount: Decimalish, overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<TroveAdjustmentDetails>>;
    // (undocumented)
    withdrawGainsFromStabilityPool(overrides?: EthersTransactionOverrides): Promise<SentEthersARTHTransaction<StabilityPoolGainsWithdrawalDetails>>;
}

// @public
export class SentEthersARTHTransaction<T = unknown> implements SentARTHTransaction<EthersTransactionResponse, ARTHReceipt<EthersTransactionReceipt, T>> {
    // @internal
    constructor(rawSentTransaction: EthersTransactionResponse, connection: EthersARTHConnection, parse: (rawReceipt: EthersTransactionReceipt) => T);
    // (undocumented)
    getReceipt(): Promise<ARTHReceipt<EthersTransactionReceipt, T>>;
    readonly rawSentTransaction: EthersTransactionResponse;
    // (undocumented)
    waitForReceipt(): Promise<MinedReceipt<EthersTransactionReceipt, T>>;
}

// @internal (undocumented)
export interface _TroveChangeWithFees<T> {
    // (undocumented)
    fee: Decimal;
    // (undocumented)
    newTrove: Trove;
    // (undocumented)
    params: T;
}

// @public
export class UnsupportedNetworkError extends Error {
    // @internal
    constructor(chainId: number);
    readonly chainId: number;
}


// (No @packageDocumentation comment for this package)

```