## 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 { 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 { ARTHReceipt } from "@mahadao/arth-base";
import { ARTHStore } from "@mahadao/arth-base";
import { ARTHStoreState } 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 interface EthersCallOverrides {
  // (undocumented)
  blockTag?: BlockTag;
}

// @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 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)
```