@aurigami/sdk 1.23.1 → 1.24.1

package/src/helpers/subgraphQuery.ts

@@ -1,17 +0,0 @@
-export function getLiquidationEventsQuery(address: string, limit: number) {
-  return `{
-    liquidationEvents(
-      first: ${limit},
-      where: {from: "${address.toLowerCase()}"}
-    ) {
-      amount
-      auTokenSymbol
-      blockTime
-      from
-      id
-      underlyingRepayAmountUSD
-      underlyingSymbol
-      underlyingRepayAmount
-    }
-  }`;
-}

package/src/helpers/transfer-event-query.ts

@@ -1,68 +0,0 @@
-import AuTokenABI from '@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json';
-import { AuToken } from '@aurigami/contracts/typechain';
-import { BigNumber as BN, Contract } from 'ethers';
-import { BlockchainEntityRead } from '../entities/BlockchainEntity';
-import { NetworkConnection } from '../types';
-
-type SimpleTransfer = {
-  from: string;
-  to: string;
-  amount: BN;
-  blockNumber: number;
-};
-
-export class TransferEventQuery extends BlockchainEntityRead {
-  auToken: AuToken;
-
-  constructor(tokenAddr: string, networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.auToken = new Contract(
-      tokenAddr,
-      AuTokenABI.abi,
-      this._networkConnection.provider
-    ) as AuToken;
-  }
-
-  /**
-   * query ERC20 transfers from/to an address & auto convert them into SimpleTransfer.
-   * The result will be sorted by blocknumber.
-   */
-  async queryERC20TransfersOf(
-    address: string,
-    fromBlock: number,
-    toBlock: number
-  ): Promise<SimpleTransfer[]> {
-    const filters = [
-      this.auToken.filters.Transfer(address, null),
-      this.auToken.filters.Transfer(null, address),
-    ];
-
-    const events = (
-      await Promise.all(
-        filters.map((filter) => this.auToken.queryFilter(filter, fromBlock, toBlock))
-      )
-    ).flat();
-
-    let results: SimpleTransfer[] = events.map((event) => {
-      return {
-        from: event.args![0],
-        to: event.args![1],
-        amount: event.args![2],
-        blockNumber: event.blockNumber,
-      };
-    });
-
-    results.sort((a, b) => a.blockNumber - b.blockNumber);
-
-    return results;
-  }
-
-  /**
-   * Get the balance of an address at a given block number.
-   *
-   * Note that this will return the balance after the block get mined.
-   */
-  async queryERC20BalanceAt(address: string, endBlock: number): Promise<BN> {
-    return this.auToken.balanceOf(address, { blockTag: endBlock + 1 });
-  }
-}

package/src/index.ts

@@ -1,14 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { ethers } from 'ethers';
-import { Logger } from 'ethers/lib/utils';
-
-ethers.utils.Logger.setLogLevel(Logger.levels.ERROR);
-BigNumber.config({ DECIMAL_PLACES: 50 });
-
-export * as abis from './abis';
-export * from './consts';
-export * from './entities';
-export * from './helpers';
-export * from './interactors';
-export * from './SDK';
-export * from './types';

package/src/interactors/Airdrop.ts

@@ -1,72 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BigNumber as BN, utils } from 'ethers';
-import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
-import * as helpers from '../helpers';
-import { Address, NetworkConnection } from '../types';
-
-export class AirdropRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-
-  public constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  /**
-   * Get redeemable rewards amount of user
-   */
-  public async getRedeemableReward(
-    campaign: string,
-    token: Address,
-    user: Address
-  ): Promise<TokenAmount> {
-    let tokenInstance: Token = new Token(token, helpers.getDecimal(token));
-
-    let rewards: BN = await this.env.auriAirdrop.getRedeemableReward(
-      utils.formatBytes32String(campaign),
-      token,
-      user
-    );
-
-    return new TokenAmount(tokenInstance, rewards.toString());
-  }
-}
-
-export class AirdropReadWrite extends AirdropRead {
-  /**
-   * Transfer rewards from multiple campaigns to msg.sender
-   */
-  public async redeemMultiple(
-    campaigns: string[],
-    tokens: Address[]
-  ): Promise<TransactionResponse> {
-    helpers.assert(
-      campaigns.length == tokens.length,
-      'campaigns and tokens must have the same length'
-    );
-    return this.env.auriAirdrop.connect(this._networkConnection.signer!).redeem(
-      campaigns.map((e) => utils.formatBytes32String(e)),
-      tokens,
-      await this._networkConnection.signer!.getAddress()
-    );
-  }
-
-  /**
-   * Redeem reward from a single campaign
-   */
-  public async redeemSingle(campaign: string, token: Address): Promise<TransactionResponse> {
-    return this.redeemMultiple([campaign], [token]);
-  }
-}
-
-export class Airdrop extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): AirdropRead {
-    return new AirdropRead(networkConnection);
-  }
-  public readWrite(networkConnection: NetworkConnection): AirdropReadWrite {
-    return new AirdropReadWrite(networkConnection);
-  }
-}

package/src/interactors/MoneyMarket.ts

@@ -1,482 +0,0 @@
-import { AuETH, AuErc20, EthRepayHelper } from '@aurigami/contracts/typechain';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { CacheType, cache } from 'cache-decorator';
-import { BigNumber as BN, Contract } from 'ethers';
-import * as abis from '../abis';
-import * as consts from '../consts';
-import { CACHE_TIMEOUT, ONE_DAY } from '../consts';
-import {
-  AuriEnv,
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYToken,
-  Token,
-  TokenAmount,
-} from '../entities';
-import * as helpers from '../helpers';
-import { calcValuation, fetchPrice, fetchValuation } from '../helpers/priceFetcher';
-import { Address, Apy, MoneyMarketDetails, NetworkConnection } from '../types';
-
-type RewardSpeeds = {
-  plyRewardSupplySpeed: BN;
-  plyRewardBorrowSpeed: BN;
-  auroraRewardSupplySpeed: BN;
-  auroraRewardBorrowSpeed: BN;
-};
-
-export class MoneyMarketRead extends BlockchainEntityRead {
-  public underlying: Token;
-  public auToken: AuErc20 | AuETH;
-  public readonly env: AuriEnv;
-  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-    if (helpers.isSameAddress(underlyingAsset, consts.ETHAddress)) {
-      this.auToken = new Contract(auToken, abis.AuETHABI.abi, networkConnection.provider) as AuETH;
-    } else {
-      this.auToken = new Contract(
-        auToken,
-        abis.AuErc20ABI.abi,
-        networkConnection.provider
-      ) as AuErc20;
-    }
-    this.underlying = new Token(underlyingAsset, helpers.getDecimal(underlyingAsset));
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getUnderlyingPrice(): Promise<BigNumber> {
-    return fetchPrice(this.underlying.address, this._networkConnection.provider);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getPlyPrice(): Promise<BigNumber> {
-    return fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  protected async getRewardSpeeds(): Promise<RewardSpeeds> {
-    var speeds = await this.env.auriLens.getRewardSpeeds(
-      this.env.comptroller.address,
-      this.auToken.address
-    );
-    return speeds;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getTotalTokenBorrowed(): Promise<TokenAmount> {
-    return new TokenAmount(this.underlying, (await this.auToken.totalBorrows()).toString());
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getTotalTokenDeposited(): Promise<TokenAmount> {
-    const [totalBorrow, totalCash] = await Promise.all([
-      this.getTotalTokenBorrowed(),
-      this.auToken.getCash(),
-    ]);
-    return new TokenAmount(
-      this.underlying,
-      BN.from(new TokenAmount(this.underlying, totalCash.toString()).rawAmount())
-        .add(totalBorrow.rawAmount())
-        .toString()
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositAPY(): Promise<BigNumber> {
-    const supplyRatePerTimestamp = await this.auToken.supplyRatePerTimestamp();
-    const supplyRatePerDay = new BigNumber(supplyRatePerTimestamp.toString())
-      .multipliedBy(ONE_DAY)
-      .div(helpers.decimalFactor(18));
-
-    return new BigNumber(supplyRatePerDay.plus(1)).pow(365).minus(1);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getBorrowAPY(): Promise<BigNumber> {
-    const borrowRatePerTimestamp = await this.auToken.borrowRatePerTimestamp();
-    const borrowRatePerDay = new BigNumber(borrowRatePerTimestamp.toString())
-      .multipliedBy(ONE_DAY)
-      .div(helpers.decimalFactor(18));
-    return new BigNumber(borrowRatePerDay.plus(1)).pow(365).minus(1);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getCollateralRatio(): Promise<BigNumber> {
-    return this.env.comptroller.markets(this.auToken.address).then((res: any) => {
-      return new BigNumber(res.collateralFactorMantissa.toString()).div(helpers.decimalFactor(18));
-    });
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getBorrowPlyAPY(): Promise<BigNumber> {
-    const [totalBorrowed, rewardSpeeds, plyPrice, underlyingPrice] = await Promise.all([
-      this.getTotalTokenBorrowed(),
-      this.getRewardSpeeds(),
-      this.getPlyPrice(),
-      this.getUnderlyingPrice(),
-    ]);
-    return helpers.calcLMRewardApr(
-      calcValuation(
-        new TokenAmount(PLYToken, rewardSpeeds.plyRewardBorrowSpeed.toString()),
-        plyPrice
-      ),
-      underlyingPrice.multipliedBy(totalBorrowed.formattedAmount()),
-      consts.ONE_YEAR
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositPlyAPY(): Promise<BigNumber> {
-    const [totalDeposited, rewardSpeeds, plyPrice, underlyingPrice] = await Promise.all([
-      this.getTotalTokenDeposited(),
-      this.getRewardSpeeds(),
-      this.getPlyPrice(),
-      this.getUnderlyingPrice(),
-    ]);
-    return helpers.calcLMRewardApr(
-      calcValuation(
-        new TokenAmount(PLYToken, rewardSpeeds.plyRewardSupplySpeed.toString()),
-        plyPrice
-      ),
-      underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-      consts.ONE_YEAR
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositNearAPY(): Promise<BigNumber> {
-    const [totalDeposited, underlyingPrice] = await Promise.all([
-      this.getTotalTokenDeposited(),
-      this.getUnderlyingPrice(),
-    ]);
-    let depositNEARApy = helpers.calcLMRewardApr(
-      await fetchValuation(this.getDepositNEARRewardPerWeek(), this._networkConnection.provider),
-      underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-      52
-    );
-    return depositNEARApy;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getBorrowNearAPY(): Promise<BigNumber> {
-    const [totalBorrowed, underlyingPrice] = await Promise.all([
-      this.getTotalTokenBorrowed(),
-      this.getUnderlyingPrice(),
-    ]);
-    let borrowNEARApy = helpers.calcLMRewardApr(
-      await fetchValuation(this.getBorrowNEARRewardPerWeek(), this._networkConnection.provider),
-      underlyingPrice.multipliedBy(totalBorrowed.formattedAmount()),
-      52
-    );
-    return borrowNEARApy;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositMetaAPY(): Promise<BigNumber> {
-    return new BigNumber(0);
-    // const [totalDeposited, underlyingPrice] = await Promise.all([
-    //   this.getTotalTokenDeposited(),
-    //   fetchPrice(this.underlying.address, this._networkConnection.provider),
-    // ]);
-    // let depositMETAApy;
-    // if (helpers.isSameAddress(this.underlying.address, consts.networkAddresses.tokens.stNEAR)) {
-    //   depositMETAApy = helpers.calcLMRewardApr(
-    //     await fetchValuation(
-    //       TokenAmount.fromAddressAndAmount(consts.networkAddresses.tokens.META, '250000', false),
-    //       this._networkConnection.provider
-    //     ),
-    //     underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-    //     12
-    //   );
-    // } else {
-    //   depositMETAApy = new BigNumber(0);
-    // }
-    // return depositMETAApy;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositStaderAPY(): Promise<BigNumber> {
-    return new BigNumber(0);
-    // const rewardStartTime = 1675346400;
-    // const currentTime = helpers.getCurrentTimestamp();
-    // if (currentTime < rewardStartTime) {
-    //   return new BigNumber(0);
-    // }
-    // const [totalDeposited, underlyingPrice] = await Promise.all([
-    //   this.getTotalTokenDeposited(),
-    //   fetchPrice(this.underlying.address, this._networkConnection.provider),
-    // ]);
-    // let depositStaderApy;
-    // if (helpers.isSameAddress(this.underlying.address, consts.networkAddresses.tokens.NEARX)) {
-    //   depositStaderApy = helpers.calcLMRewardApr(
-    //     await fetchValuation(
-    //       TokenAmount.fromAddressAndAmount(consts.networkAddresses.tokens.STADER, '40', false),
-    //       this._networkConnection.provider
-    //     ),
-    //     underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-    //     365
-    //   );
-    // } else {
-    //   depositStaderApy = new BigNumber(0);
-    // }
-    // return depositStaderApy;
-  }
-
-  public async getDetails(): Promise<MoneyMarketDetails> {
-    const [totalDeposited, totalBorrowed, depositAPY, borrowAPY, collateralRatio, rewardSpeeds] =
-      await Promise.all([
-        this.getTotalTokenDeposited(),
-        this.getTotalTokenBorrowed(),
-        this.getDepositAPY(),
-        this.getBorrowAPY(),
-        this.getCollateralRatio(),
-        this.getRewardSpeeds(),
-      ]);
-    const [
-      depositPlyAPY,
-      borrowPlyAPY,
-      depositNearAPY,
-      borrowNearAPY,
-      depositMetaAPY,
-      staderDepositApy,
-    ] = await Promise.all([
-      this.getDepositPlyAPY(),
-      this.getBorrowPlyAPY(),
-      this.getDepositNearAPY(),
-      this.getBorrowNearAPY(),
-      this.getDepositMetaAPY(),
-      this.getDepositStaderAPY(),
-    ]);
-    return {
-      auTokenAddress: this.auToken.address,
-      totalTokenDeposited: totalDeposited,
-      totalTokenBorrowed: totalBorrowed,
-      depositApy: depositAPY.toNumber(),
-      depositPlyApy: depositPlyAPY.toNumber(),
-      borrowApy: borrowAPY.toNumber(),
-      borrowPlyApy: borrowPlyAPY.toNumber() * -1,
-      collateralRatio: collateralRatio.toNumber(),
-      depositPlyPerWeek: new TokenAmount(
-        PLYToken,
-        rewardSpeeds.plyRewardSupplySpeed.mul(consts.ONE_DAY).mul(7).toString()
-      ),
-      borrowPlyPerWeek: new TokenAmount(
-        PLYToken,
-        rewardSpeeds.plyRewardBorrowSpeed.mul(consts.ONE_DAY).mul(7).toString()
-      ),
-      depositNEARApy: depositNearAPY.toNumber(),
-      borrowNEARApy: borrowNearAPY.toNumber() * -1,
-      depositMETAApy: depositMetaAPY.toNumber(),
-      staderDepositApy: staderDepositApy.toNumber(),
-    };
-  }
-
-  public async getUserBorrowBalance(userAddress: string): Promise<TokenAmount> {
-    const totalBorrow: BN = await this.auToken.callStatic.borrowBalanceCurrent(userAddress);
-    return new TokenAmount(this.underlying, totalBorrow.toString());
-  }
-
-  public async getUserDepositBalance(userAddress: string): Promise<TokenAmount> {
-    const totalDeposit: BN = await this.auToken.callStatic.balanceOfUnderlying(userAddress);
-    return new TokenAmount(this.underlying, totalDeposit.toString());
-  }
-
-  private getDepositNEARRewardPerWeek(): TokenAmount {
-    const NEARToken = new Token(
-      consts.networkAddresses.tokens.WNEAR,
-      helpers.getDecimal(consts.networkAddresses.tokens.WNEAR)
-    );
-    const rewardStartTime = 1650636000;
-    const rewardStopTime = 1651845600; // May 06, 2022 2 PM GMT
-    const currentTime = helpers.getCurrentTimestamp();
-    if (currentTime <= rewardStopTime && currentTime > rewardStartTime) {
-      const reward =
-        consts.DEPOSIT_NEAR_REWARDS_PER_WEEK[this.underlying.address.toLocaleLowerCase()] ?? '0';
-      return new TokenAmount(NEARToken, reward, false);
-    } else {
-      return new TokenAmount(NEARToken, '0');
-    }
-  }
-
-  private getBorrowNEARRewardPerWeek(): TokenAmount {
-    const NEARToken = new Token(
-      consts.networkAddresses.tokens.WNEAR,
-      helpers.getDecimal(consts.networkAddresses.tokens.WNEAR)
-    );
-    const rewardStartTime = 1650636000;
-    const rewardStopTime = 1651845600; // May 06, 2022 2 PM GMT
-    const currentTime = helpers.getCurrentTimestamp();
-    if (currentTime <= rewardStopTime && currentTime > rewardStartTime) {
-      const reward =
-        consts.BORROW_NEAR_REWARDS_PER_WEEK[this.underlying.address.toLocaleLowerCase()] ?? '0';
-      return new TokenAmount(NEARToken, reward, false);
-    } else {
-      return new TokenAmount(NEARToken, '0');
-    }
-  }
-  public async mintCap(): Promise<TokenAmount> {
-    return new TokenAmount(
-      this.underlying,
-      (await this.env.comptroller.mintCaps(this.auToken.address)).toString()
-    );
-  }
-  public async borrowCap(): Promise<TokenAmount> {
-    return new TokenAmount(
-      this.underlying,
-      (await this.env.comptroller.borrowCaps(this.auToken.address)).toString()
-    );
-  }
-
-  public async getDepositBorrowValue(userAddress: Address) {
-    const [price, depositBalance, borrowBalance] = await Promise.all([
-      this.getUnderlyingPrice(),
-      this.getUserDepositBalance(userAddress),
-      this.getUserBorrowBalance(userAddress),
-    ]);
-    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
-    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
-    return {
-      suppliedValue,
-      borrowedValue,
-    };
-  }
-
-  public async getApyWithoutIncentive(userAddress: Address): Promise<Apy> {
-    const [price, depositApy, borrowApy, depositBalance, borrowBalance] = await Promise.all([
-      this.getUnderlyingPrice(),
-      this.getDepositAPY(),
-      this.getBorrowAPY(),
-      this.getUserDepositBalance(userAddress),
-      this.getUserBorrowBalance(userAddress),
-    ]);
-    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
-    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
-    const sum = helpers.calcNetApy(suppliedValue, depositApy, borrowedValue, borrowApy);
-    return {
-      sum,
-      suppliedValue,
-      borrowedValue,
-    };
-  }
-
-  public async getApyWithIncentive(userAddress: Address): Promise<Apy> {
-    const [
-      price,
-      depositApy,
-      borrowApy,
-      depositBalance,
-      borrowBalance,
-      nearDepositApy,
-      plyDepositApy,
-      metaDepositApy,
-      nearBorrowApy,
-      plyBorrowApy,
-    ] = await Promise.all([
-      this.getUnderlyingPrice(),
-      this.getDepositAPY(),
-      this.getBorrowAPY(),
-      this.getUserDepositBalance(userAddress),
-      this.getUserBorrowBalance(userAddress),
-      this.getDepositNearAPY(),
-      this.getDepositPlyAPY(),
-      this.getDepositMetaAPY(),
-      this.getBorrowNearAPY(),
-      this.getBorrowPlyAPY(),
-    ]);
-    // idk why i cannot put this to promise.all, txds keep getting error
-    const staderDepositApy = await this.getDepositStaderAPY();
-    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
-    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
-    const totalDepositApy = depositApy
-      .plus(nearDepositApy)
-      .plus(plyDepositApy)
-      .plus(metaDepositApy)
-      .plus(staderDepositApy);
-    const totalBorrowApy = borrowApy.plus(nearBorrowApy).plus(plyBorrowApy);
-    const sum = helpers.calcNetApy(suppliedValue, totalDepositApy, borrowedValue, totalBorrowApy);
-    return {
-      sum,
-      suppliedValue,
-      borrowedValue,
-    };
-  }
-}
-
-export class MoneyMarketReadWrite extends MoneyMarketRead {
-  protected _EthRepayHelper: EthRepayHelper;
-  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
-    super(networkConnection, auToken, underlyingAsset);
-    this._EthRepayHelper = new Contract(
-      consts.networkAddresses.misc.ETHREPAYHELPER,
-      abis.EthRepayHelperABI.abi,
-      networkConnection.provider
-    ) as EthRepayHelper;
-  }
-
-  public async deposit(amount: TokenAmount): Promise<TransactionResponse> {
-    if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
-      return (this.auToken as AuETH)
-        .connect(this._networkConnection.signer!)
-        .mint({ value: amount.rawAmount() });
-    } else {
-      return (this.auToken as AuErc20)
-        .connect(this._networkConnection.signer!)
-        .mint(amount.rawAmount());
-    }
-  }
-  public async borrow(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.auToken.connect(this._networkConnection.signer!).borrow(amount.rawAmount());
-  }
-  public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
-    if (new BigNumber(amount.rawAmount()).lt(0)) {
-      return this.auToken.connect(this._networkConnection.signer!).redeemUnderlying(consts.INF);
-    }
-    return this.auToken
-      .connect(this._networkConnection.signer!)
-      .redeemUnderlying(amount.rawAmount());
-  }
-  public async repay(amount: TokenAmount): Promise<TransactionResponse> {
-    if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
-      return this._EthRepayHelper
-        .connect(this._networkConnection.signer!)
-        .repayBorrow({ value: amount.rawAmount() });
-    } else {
-      if (new BigNumber(amount.rawAmount()).lt(0)) {
-        return this.auToken.connect(this._networkConnection.signer!).repayBorrow(consts.INF);
-      } else {
-        return this.auToken
-          .connect(this._networkConnection.signer!)
-          .repayBorrow(amount.rawAmount());
-      }
-    }
-  }
-  public async enableCollateral(): Promise<TransactionResponse> {
-    return this.env.comptroller
-      .connect(this._networkConnection.signer!)
-      .enterMarkets([this.auToken.address]);
-  }
-  public async disableCollateral(): Promise<TransactionResponse> {
-    return this.env.comptroller
-      .connect(this._networkConnection.signer!)
-      .exitMarket(this.auToken.address);
-  }
-}
-
-export class MoneyMarket extends BlockchainEntity {
-  protected address: Address;
-
-  protected underlying: Address;
-  constructor(address: string, underlying: string) {
-    super();
-    this.address = helpers.validateAndParseAddress(address);
-    this.underlying = helpers.validateAndParseAddress(underlying);
-  }
-  public read(networkConnection: NetworkConnection): MoneyMarketRead {
-    return new MoneyMarketRead(networkConnection, this.address, this.underlying);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): MoneyMarketReadWrite {
-    return new MoneyMarketReadWrite(networkConnection, this.address, this.underlying);
-  }
-}