@sovryn-zero/lib-base 0.1.0

package/src/PopulatableLiquity.ts

@@ -0,0 +1,280 @@
+import { Decimal, Decimalish } from "./Decimal";
+import { TroveAdjustmentParams, TroveCreationParams } from "./Trove";
+import { LiquityReceipt, SendableLiquity, SentLiquityTransaction } from "./SendableLiquity";
+
+import {
+  CollateralGainTransferDetails,
+  LiquidationDetails,
+  RedemptionDetails,
+  StabilityDepositChangeDetails,
+  StabilityPoolGainsWithdrawalDetails,
+  TroveAdjustmentDetails,
+  TroveClosureDetails,
+  TroveCreationDetails
+} from "./TransactableLiquity";
+
+/**
+ * A transaction that has been prepared for sending.
+ *
+ * @remarks
+ * Implemented by {@link @sovryn-zero/lib-ethers#PopulatedEthersLiquityTransaction}.
+ *
+ * @public
+ */
+export interface PopulatedLiquityTransaction<
+  P = unknown,
+  T extends SentLiquityTransaction = SentLiquityTransaction
+> {
+  /** Implementation-specific populated transaction object. */
+  readonly rawPopulatedTransaction: P;
+
+  /**
+   * Send the transaction.
+   *
+   * @returns An object that implements {@link @sovryn-zero/lib-base#SentLiquityTransaction}.
+   */
+  send(): Promise<T>;
+}
+
+/**
+ * A redemption transaction that has been prepared for sending.
+ *
+ * @remarks
+ * The Zero protocol fulfills redemptions by repaying the debt of Troves in ascending order of
+ * their collateralization ratio, and taking a portion of their collateral in exchange. Due to the
+ * {@link @sovryn-zero/lib-base#ZUSD_MINIMUM_DEBT | minimum debt} requirement that Troves must fulfill,
+ * some ZUSD amounts are not possible to redeem exactly.
+ *
+ * When {@link @sovryn-zero/lib-base#PopulatableLiquity.redeemZUSD | redeemZUSD()} is called with an
+ * amount that can't be fully redeemed, the amount will be truncated (see the `redeemableZUSDAmount`
+ * property). When this happens, the redeemer can either redeem the truncated amount by sending the
+ * transaction unchanged, or prepare a new transaction by
+ * {@link @sovryn-zero/lib-base#PopulatedRedemption.increaseAmountByMinimumNetDebt | increasing the amount}
+ * to the next lowest possible value, which is the sum of the truncated amount and
+ * {@link @sovryn-zero/lib-base#ZUSD_MINIMUM_NET_DEBT}.
+ *
+ * @public
+ */
+export interface PopulatedRedemption<P = unknown, S = unknown, R = unknown>
+  extends PopulatedLiquityTransaction<
+    P,
+    SentLiquityTransaction<S, LiquityReceipt<R, RedemptionDetails>>
+  > {
+  /** Amount of ZUSD the redeemer is trying to redeem. */
+  readonly attemptedZUSDAmount: Decimal;
+
+  /** Maximum amount of ZUSD that is currently redeemable from `attemptedZUSDAmount`. */
+  readonly redeemableZUSDAmount: Decimal;
+
+  /** Whether `redeemableZUSDAmount` is less than `attemptedZUSDAmount`. */
+  readonly isTruncated: boolean;
+
+  /**
+   * Prepare a new transaction by increasing the attempted amount to the next lowest redeemable
+   * value.
+   *
+   * @param maxRedemptionRate - Maximum acceptable
+   *                            {@link @sovryn-zero/lib-base#Fees.redemptionRate | redemption rate} to
+   *                            use in the new transaction.
+   *
+   * @remarks
+   * If `maxRedemptionRate` is omitted, the original transaction's `maxRedemptionRate` is reused
+   * unless that was also omitted, in which case the current redemption rate (based on the increased
+   * amount) plus 0.1% is used as maximum acceptable rate.
+   */
+  increaseAmountByMinimumNetDebt(
+    maxRedemptionRate?: Decimalish
+  ): Promise<PopulatedRedemption<P, S, R>>;
+}
+
+/** @internal */
+export type _PopulatableFrom<T, P> = {
+  [M in keyof T]: T[M] extends (...args: infer A) => Promise<infer U>
+    ? U extends SentLiquityTransaction
+      ? (...args: A) => Promise<PopulatedLiquityTransaction<P, U>>
+      : never
+    : never;
+};
+
+/**
+ * Prepare Zero transactions for sending.
+ *
+ * @remarks
+ * The functions return an object implementing {@link PopulatedLiquityTransaction}, which can be
+ * used to send the transaction and get a {@link SentLiquityTransaction}.
+ *
+ * Implemented by {@link @sovryn-zero/lib-ethers#PopulatableEthersLiquity}.
+ *
+ * @public
+ */
+export interface PopulatableLiquity<R = unknown, S = unknown, P = unknown>
+  extends _PopulatableFrom<SendableLiquity<R, S>, P> {
+  // Methods re-declared for documentation purposes
+
+  /** {@inheritDoc TransactableLiquity.openTrove} */
+  openTrove(
+    params: TroveCreationParams<Decimalish>,
+    maxBorrowingRate?: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, TroveCreationDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.closeTrove} */
+  closeTrove(): Promise<
+    PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, TroveClosureDetails>>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.adjustTrove} */
+  adjustTrove(
+    params: TroveAdjustmentParams<Decimalish>,
+    maxBorrowingRate?: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.depositCollateral} */
+  depositCollateral(
+    amount: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.withdrawCollateral} */
+  withdrawCollateral(
+    amount: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.borrowZUSD} */
+  borrowZUSD(
+    amount: Decimalish,
+    maxBorrowingRate?: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.repayZUSD} */
+  repayZUSD(
+    amount: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>
+    >
+  >;
+
+  /** @internal */
+  setPrice(
+    price: Decimalish
+  ): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+
+  /** {@inheritDoc TransactableLiquity.liquidate} */
+  liquidate(
+    address: string | string[]
+  ): Promise<
+    PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.liquidateUpTo} */
+  liquidateUpTo(
+    maximumNumberOfTrovesToLiquidate: number
+  ): Promise<
+    PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.depositZUSDInStabilityPool} */
+  depositZUSDInStabilityPool(
+    amount: Decimalish,
+    frontendTag?: string
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.withdrawZUSDFromStabilityPool} */
+  withdrawZUSDFromStabilityPool(
+    amount: Decimalish
+  ): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.withdrawGainsFromStabilityPool} */
+  withdrawGainsFromStabilityPool(): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, StabilityPoolGainsWithdrawalDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.transferCollateralGainToTrove} */
+  transferCollateralGainToTrove(): Promise<
+    PopulatedLiquityTransaction<
+      P,
+      SentLiquityTransaction<S, LiquityReceipt<R, CollateralGainTransferDetails>>
+    >
+  >;
+
+  /** {@inheritDoc TransactableLiquity.sendZUSD} */
+  sendZUSD(
+    toAddress: string,
+    amount: Decimalish
+  ): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+
+  /** {@inheritDoc TransactableLiquity.sendZERO} */
+  sendZERO(
+    toAddress: string,
+    amount: Decimalish
+  ): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+
+  /** {@inheritDoc TransactableLiquity.redeemZUSD} */
+  redeemZUSD(
+    amount: Decimalish,
+    maxRedemptionRate?: Decimalish
+  ): Promise<PopulatedRedemption<P, S, R>>;
+
+  /** {@inheritDoc TransactableLiquity.claimCollateralSurplus} */
+  claimCollateralSurplus(): Promise<
+    PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.stakeZERO} */
+  stakeZERO(
+    amount: Decimalish
+  ): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+
+  /** {@inheritDoc TransactableLiquity.unstakeZERO} */
+  unstakeZERO(
+    amount: Decimalish
+  ): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+
+  /** {@inheritDoc TransactableLiquity.withdrawGainsFromStaking} */
+  withdrawGainsFromStaking(): Promise<
+    PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.registerFrontend} */
+  registerFrontend(
+    kickbackRate: Decimalish
+  ): Promise<PopulatedLiquityTransaction<P, SentLiquityTransaction<S, LiquityReceipt<R, void>>>>;
+}

package/src/ReadableLiquity.ts

@@ -0,0 +1,175 @@
+import { Decimal } from "./Decimal";
+import { Trove, TroveWithPendingRedistribution, UserTrove } from "./Trove";
+import { StabilityDeposit } from "./StabilityDeposit";
+import { Fees } from "./Fees";
+import { ZEROStake } from "./ZEROStake";
+
+/**
+ * Represents whether an address has been registered as a Zero frontend.
+ *
+ * @remarks
+ * Returned by the {@link ReadableLiquity.getFrontendStatus | getFrontendStatus()} function.
+ *
+ * When `status` is `"registered"`, `kickbackRate` gives the frontend's kickback rate as a
+ * {@link Decimal} between 0 and 1.
+ *
+ * @public
+ */
+export type FrontendStatus =
+  | { status: "unregistered" }
+  | { status: "registered"; kickbackRate: Decimal };
+
+/**
+ * Parameters of the {@link ReadableLiquity.(getTroves:2) | getTroves()} function.
+ *
+ * @public
+ */
+export interface TroveListingParams {
+  /** Number of Troves to retrieve. */
+  readonly first: number;
+
+  /** How the Troves should be sorted. */
+  readonly sortedBy: "ascendingCollateralRatio" | "descendingCollateralRatio";
+
+  /** Index of the first Trove to retrieve from the sorted list. */
+  readonly startingAt?: number;
+
+  /**
+   * When set to `true`, the retrieved Troves won't include the liquidation shares received since
+   * the last time they were directly modified.
+   *
+   * @remarks
+   * Changes the type of returned Troves to {@link TroveWithPendingRedistribution}.
+   */
+  readonly beforeRedistribution?: boolean;
+}
+
+/**
+ * Read the state of the Zero protocol.
+ *
+ * @remarks
+ * Implemented by {@link @sovryn-zero/lib-ethers#EthersLiquity}.
+ *
+ * @public
+ */
+export interface ReadableLiquity {
+  /**
+   * Get the total collateral and debt per stake that has been liquidated through redistribution.
+   *
+   * @remarks
+   * Needed when dealing with instances of {@link @sovryn-zero/lib-base#TroveWithPendingRedistribution}.
+   */
+  getTotalRedistributed(): Promise<Trove>;
+
+  /**
+   * Get a Trove in its state after the last direct modification.
+   *
+   * @param address - Address that owns the Trove.
+   *
+   * @remarks
+   * The current state of a Trove can be fetched using
+   * {@link @sovryn-zero/lib-base#ReadableLiquity.getTrove | getTrove()}.
+   */
+  getTroveBeforeRedistribution(address?: string): Promise<TroveWithPendingRedistribution>;
+
+  /**
+   * Get the current state of a Trove.
+   *
+   * @param address - Address that owns the Trove.
+   */
+  getTrove(address?: string): Promise<UserTrove>;
+
+  /**
+   * Get number of Troves that are currently open.
+   */
+  getNumberOfTroves(): Promise<number>;
+
+  /**
+   * Get the current price of the native currency (e.g. Ether) in USD.
+   */
+  getPrice(): Promise<Decimal>;
+
+  /**
+   * Get the total amount of collateral and debt in the Zero system.
+   */
+  getTotal(): Promise<Trove>;
+
+  /**
+   * Get the current state of a Stability Deposit.
+   *
+   * @param address - Address that owns the Stability Deposit.
+   */
+  getStabilityDeposit(address?: string): Promise<StabilityDeposit>;
+
+  /**
+   * Get the remaining ZERO that will be collectively rewarded to stability depositors.
+   */
+  getRemainingStabilityPoolZEROReward(): Promise<Decimal>;
+
+  /**
+   * Get the total amount of ZUSD currently deposited in the Stability Pool.
+   */
+  getZUSDInStabilityPool(): Promise<Decimal>;
+
+  /**
+   * Get the amount of ZUSD held by an address.
+   *
+   * @param address - Address whose balance should be retrieved.
+   */
+  getZUSDBalance(address?: string): Promise<Decimal>;
+
+  /**
+   * Get the amount of ZERO held by an address.
+   *
+   * @param address - Address whose balance should be retrieved.
+   */
+  getZEROBalance(address?: string): Promise<Decimal>;
+
+  /**
+   * Get the amount of leftover collateral available for withdrawal by an address.
+   *
+   * @remarks
+   * When a Trove gets liquidated or redeemed, any collateral it has above 110% (in case of
+   * liquidation) or 100% collateralization (in case of redemption) gets sent to a pool, where it
+   * can be withdrawn from using
+   * {@link @sovryn-zero/lib-base#TransactableLiquity.claimCollateralSurplus | claimCollateralSurplus()}.
+   */
+  getCollateralSurplusBalance(address?: string): Promise<Decimal>;
+
+  /** @internal */
+  getTroves(
+    params: TroveListingParams & { beforeRedistribution: true }
+  ): Promise<TroveWithPendingRedistribution[]>;
+
+  /**
+   * Get a slice from the list of Troves.
+   *
+   * @param params - Controls how the list is sorted, and where the slice begins and ends.
+   * @returns Pairs of owner addresses and their Troves.
+   */
+  getTroves(params: TroveListingParams): Promise<UserTrove[]>;
+
+  /**
+   * Get a calculator for current fees.
+   */
+  getFees(): Promise<Fees>;
+
+  /**
+   * Get the current state of an ZERO Stake.
+   *
+   * @param address - Address that owns the ZERO Stake.
+   */
+  getZEROStake(address?: string): Promise<ZEROStake>;
+
+  /**
+   * Get the total amount of ZERO currently staked.
+   */
+  getTotalStakedZERO(): Promise<Decimal>;
+
+  /**
+   * Check whether an address is registered as a Zero frontend, and what its kickback rate is.
+   *
+   * @param address - Address to check.
+   */
+  getFrontendStatus(address?: string): Promise<FrontendStatus>;
+}

package/src/SendableLiquity.ts

@@ -0,0 +1,251 @@
+import { Decimalish } from "./Decimal";
+import { TroveAdjustmentParams, TroveCreationParams } from "./Trove";
+
+import {
+  CollateralGainTransferDetails,
+  LiquidationDetails,
+  RedemptionDetails,
+  StabilityDepositChangeDetails,
+  StabilityPoolGainsWithdrawalDetails,
+  TransactableLiquity,
+  TroveAdjustmentDetails,
+  TroveClosureDetails,
+  TroveCreationDetails
+} from "./TransactableLiquity";
+
+/**
+ * A transaction that has already been sent.
+ *
+ * @remarks
+ * Implemented by {@link @sovryn-zero/lib-ethers#SentEthersLiquityTransaction}.
+ *
+ * @public
+ */
+export interface SentLiquityTransaction<S = unknown, T extends LiquityReceipt = LiquityReceipt> {
+  /** Implementation-specific sent transaction object. */
+  readonly rawSentTransaction: S;
+
+  /**
+   * Check whether the transaction has been mined, and whether it was successful.
+   *
+   * @remarks
+   * Unlike {@link @sovryn-zero/lib-base#SentLiquityTransaction.waitForReceipt | waitForReceipt()},
+   * this function doesn't wait for the transaction to be mined.
+   */
+  getReceipt(): Promise<T>;
+
+  /**
+   * Wait for the transaction to be mined, and check whether it was successful.
+   *
+   * @returns Either a {@link @sovryn-zero/lib-base#FailedReceipt} or a
+   *          {@link @sovryn-zero/lib-base#SuccessfulReceipt}.
+   */
+  waitForReceipt(): Promise<Extract<T, MinedReceipt>>;
+}
+
+/**
+ * Indicates that the transaction hasn't been mined yet.
+ *
+ * @remarks
+ * Returned by {@link SentLiquityTransaction.getReceipt}.
+ *
+ * @public
+ */
+export type PendingReceipt = { status: "pending" };
+
+/** @internal */
+export const _pendingReceipt: PendingReceipt = { status: "pending" };
+
+/**
+ * Indicates that the transaction has been mined, but it failed.
+ *
+ * @remarks
+ * The `rawReceipt` property is an implementation-specific transaction receipt object.
+ *
+ * Returned by {@link SentLiquityTransaction.getReceipt} and
+ * {@link SentLiquityTransaction.waitForReceipt}.
+ *
+ * @public
+ */
+export type FailedReceipt<R = unknown> = { status: "failed"; rawReceipt: R };
+
+/** @internal */
+export const _failedReceipt = <R>(rawReceipt: R): FailedReceipt<R> => ({
+  status: "failed",
+  rawReceipt
+});
+
+/**
+ * Indicates that the transaction has succeeded.
+ *
+ * @remarks
+ * The `rawReceipt` property is an implementation-specific transaction receipt object.
+ *
+ * The `details` property may contain more information about the transaction.
+ * See the return types of {@link TransactableLiquity} functions for the exact contents of `details`
+ * for each type of Zero transaction.
+ *
+ * Returned by {@link SentLiquityTransaction.getReceipt} and
+ * {@link SentLiquityTransaction.waitForReceipt}.
+ *
+ * @public
+ */
+export type SuccessfulReceipt<R = unknown, D = unknown> = {
+  status: "succeeded";
+  rawReceipt: R;
+  details: D;
+};
+
+/** @internal */
+export const _successfulReceipt = <R, D>(
+  rawReceipt: R,
+  details: D,
+  toString?: () => string
+): SuccessfulReceipt<R, D> => ({
+  status: "succeeded",
+  rawReceipt,
+  details,
+  ...(toString ? { toString } : {})
+});
+
+/**
+ * Either a {@link FailedReceipt} or a {@link SuccessfulReceipt}.
+ *
+ * @public
+ */
+export type MinedReceipt<R = unknown, D = unknown> = FailedReceipt<R> | SuccessfulReceipt<R, D>;
+
+/**
+ * One of either a {@link PendingReceipt}, a {@link FailedReceipt} or a {@link SuccessfulReceipt}.
+ *
+ * @public
+ */
+export type LiquityReceipt<R = unknown, D = unknown> = PendingReceipt | MinedReceipt<R, D>;
+
+/** @internal */
+export type _SendableFrom<T, R, S> = {
+  [M in keyof T]: T[M] extends (...args: infer A) => Promise<infer D>
+    ? (...args: A) => Promise<SentLiquityTransaction<S, LiquityReceipt<R, D>>>
+    : never;
+};
+
+/**
+ * Send Zero transactions.
+ *
+ * @remarks
+ * The functions return an object implementing {@link SentLiquityTransaction}, which can be used
+ * to monitor the transaction and get its details when it succeeds.
+ *
+ * Implemented by {@link @sovryn-zero/lib-ethers#SendableEthersLiquity}.
+ *
+ * @public
+ */
+export interface SendableLiquity<R = unknown, S = unknown>
+  extends _SendableFrom<TransactableLiquity, R, S> {
+  // Methods re-declared for documentation purposes
+
+  /** {@inheritDoc TransactableLiquity.openTrove} */
+  openTrove(
+    params: TroveCreationParams<Decimalish>,
+    maxBorrowingRate?: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveCreationDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.closeTrove} */
+  closeTrove(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveClosureDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.adjustTrove} */
+  adjustTrove(
+    params: TroveAdjustmentParams<Decimalish>,
+    maxBorrowingRate?: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.depositCollateral} */
+  depositCollateral(
+    amount: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.withdrawCollateral} */
+  withdrawCollateral(
+    amount: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.borrowZUSD} */
+  borrowZUSD(
+    amount: Decimalish,
+    maxBorrowingRate?: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.repayZUSD} */
+  repayZUSD(
+    amount: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, TroveAdjustmentDetails>>>;
+
+  /** @internal */
+  setPrice(price: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.liquidate} */
+  liquidate(
+    address: string | string[]
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.liquidateUpTo} */
+  liquidateUpTo(
+    maximumNumberOfTrovesToLiquidate: number
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, LiquidationDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.depositZUSDInStabilityPool} */
+  depositZUSDInStabilityPool(
+    amount: Decimalish,
+    frontendTag?: string
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.withdrawZUSDFromStabilityPool} */
+  withdrawZUSDFromStabilityPool(
+    amount: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, StabilityDepositChangeDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.withdrawGainsFromStabilityPool} */
+  withdrawGainsFromStabilityPool(): Promise<
+    SentLiquityTransaction<S, LiquityReceipt<R, StabilityPoolGainsWithdrawalDetails>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.transferCollateralGainToTrove} */
+  transferCollateralGainToTrove(): Promise<
+    SentLiquityTransaction<S, LiquityReceipt<R, CollateralGainTransferDetails>>
+  >;
+
+  /** {@inheritDoc TransactableLiquity.sendZUSD} */
+  sendZUSD(
+    toAddress: string,
+    amount: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.sendZERO} */
+  sendZERO(
+    toAddress: string,
+    amount: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.redeemZUSD} */
+  redeemZUSD(
+    amount: Decimalish,
+    maxRedemptionRate?: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, RedemptionDetails>>>;
+
+  /** {@inheritDoc TransactableLiquity.claimCollateralSurplus} */
+  claimCollateralSurplus(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.stakeZERO} */
+  stakeZERO(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.unstakeZERO} */
+  unstakeZERO(amount: Decimalish): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.withdrawGainsFromStaking} */
+  withdrawGainsFromStaking(): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+
+  /** {@inheritDoc TransactableLiquity.registerFrontend} */
+  registerFrontend(
+    kickbackRate: Decimalish
+  ): Promise<SentLiquityTransaction<S, LiquityReceipt<R, void>>>;
+}