@aurigami/sdk 1.24.0 → 1.24.1

package/src/interactors/Papermill.ts

@@ -1,185 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN } from 'ethers';
-import * as consts from '../consts';
-import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
-import * as helpers from '../helpers';
-import { Address, NetworkConnection, UserLockingDetails } from '../types';
-
-const LOCKING_DENOMINATOR = BN.from(10000);
-export class PapermillRead extends BlockchainEntityRead {
-  public readonly plyToken: Token;
-  public readonly pulpToken: Token;
-  public readonly env: AuriEnv;
-
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-
-    let plyAddress = consts.networkAddresses.tokens.PLY;
-    let pulpAddress = consts.networkAddresses.tokens.PULP;
-
-    this.plyToken = new Token(plyAddress, helpers.getDecimal(plyAddress));
-    this.pulpToken = new Token(pulpAddress, helpers.getDecimal(pulpAddress));
-  }
-
-  public async getPlyBalance(userAddress: Address): Promise<TokenAmount> {
-    const plyBalance = await this.env.ply.raw.balanceOf(userAddress);
-    return new TokenAmount(this.plyToken, plyBalance.toString());
-  }
-
-  public async getPulpBalance(userAddress: Address): Promise<TokenAmount> {
-    const pulpBalance = await this.env.pulp.raw.balanceOf(userAddress);
-    return new TokenAmount(this.pulpToken, pulpBalance.toString());
-  }
-
-  /**
-   * Get all unclaimed PLY reward of the user in all markets + all staking pools
-   */
-  public async getUnclaimedPlyReward(userAddress: Address): Promise<TokenAmount> {
-    let rewardBalancesMetadata = await this.env.auriLens.raw.callStatic.claimRewards(
-      this.env.comptroller.address,
-      this.env.auriFairLaunch.address,
-      consts.ALL_STAKING_POOLS,
-      { from: userAddress }
-    );
-
-    return new TokenAmount(this.plyToken, rewardBalancesMetadata.plyAccrured.toString());
-  }
-
-  public getWeek(timestamp: number): number {
-    return BN.from(timestamp - consts.REWARD_CLAIM_START)
-      .div(consts.ONE_WEEK)
-      .toNumber();
-  }
-
-  /**
-   * Get all locking details of the user in all markets + all staking pools
-   */
-  public async getLockingDetails(userAddress: Address): Promise<UserLockingDetails> {
-    const currentWeek = this.getWeek(helpers.getCurrentTimestamp());
-
-    const values = await Promise.all([
-      this.env.auriLens.raw.getPercentLock(this.env.pulp.address, userAddress, currentWeek),
-      this.env.auriLens.raw.getPercentLock(this.env.pulp.address, userAddress, currentWeek + 1),
-      this.getUnclaimedPlyReward(userAddress),
-    ]);
-
-    let percentLockCurrentWeek = BN.from(values[0]);
-    let percentLockNextWeek = BN.from(values[1]);
-    let totalRewards = values[2] as TokenAmount;
-
-    let [pulpAmountCurrentWeek, plyAmountCurrentWeek] = await this.env.pulp.raw.calcLockAmount(
-      userAddress,
-      totalRewards.rawAmount()
-    );
-
-    // Predict next week lock amount = totalRewards * percentLock next week
-    // This doesn't take (the reward that user might earn in the next week) into account
-    let plyAmountNextWeek = percentLockNextWeek
-      .mul(totalRewards.rawAmount())
-      .div(LOCKING_DENOMINATOR);
-    let pulpAmountNextWeek = BN.from(totalRewards.rawAmount()).sub(plyAmountNextWeek);
-
-    // we need to divide these two number by 10000 and multiple by 100 to get the percentage
-    // I need to use BigNumber to do this because BN of ethers.js doesn't support floating point
-    let currentUnlockPortion = LOCKING_DENOMINATOR.sub(percentLockCurrentWeek).toString();
-    let nextUnlockPortion = LOCKING_DENOMINATOR.sub(percentLockNextWeek).toString();
-
-    return {
-      vestingStart: consts.REWARD_CLAIM_START,
-      currentUnlockPortion: new BigNumber(currentUnlockPortion).dividedBy(100).toNumber(),
-      accruedPly: totalRewards,
-      currentPly: new TokenAmount(this.plyToken, plyAmountCurrentWeek.toString()),
-      currentPulp: new TokenAmount(this.pulpToken, pulpAmountCurrentWeek.toString()),
-      //
-      nextUnlockPortion: new BigNumber(nextUnlockPortion).dividedBy(100).toNumber(),
-      nextPly: new TokenAmount(this.plyToken, plyAmountNextWeek.toString()),
-      nextPulp: new TokenAmount(this.pulpToken, pulpAmountNextWeek.toString()),
-    };
-  }
-
-  /**
-   * Get the first timestamp that the unlockPortion reach the target
-   *
-   * @param userAddress currently doesn't matter
-   * @param targetUnlockPortion unlockPortion target
-   */
-  public async getTimestampToUnlock(
-    userAddress: Address,
-    targetUnlockPortion: number
-  ): Promise<number> {
-    let weekId = await this.env.auriLens.raw.getWeekToUnlock(
-      this.env.pulp.address,
-      userAddress,
-      targetUnlockPortion * 100
-    );
-
-    return consts.REWARD_CLAIM_START + consts.ONE_WEEK * weekId.toNumber();
-  }
-
-  /**
-   * Get the start timestamp of next week of the papermill contract.
-   *
-   * This is a sync function!
-   *
-   * @returns the timestamp in seconds
-   */
-  public getNextWeekTimestamp(): number {
-    const nextWeek = this.getWeek(helpers.getCurrentTimestamp()) + 1;
-    return consts.REWARD_CLAIM_START + consts.ONE_WEEK * nextWeek;
-  }
-
-  public async getUnlockPortionAt(userAddress: Address, timestamp: number): Promise<number> {
-    let lockPortion = await this.env.auriLens.raw.getPercentLock(
-      this.env.pulp.address,
-      userAddress,
-      this.getWeek(timestamp)
-    );
-
-    let unlockPortion = LOCKING_DENOMINATOR.sub(lockPortion);
-
-    return unlockPortion.toNumber() / 100;
-  }
-}
-
-export class PapermillReadWrite extends PapermillRead {
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-  }
-
-  /**
-   * Redeem PLY from PULP and transfer PLY to another address
-   * @param recipient Address that will receive the PLY.
-   * @param amount Amount of PULP to be converted to PLY.
-   * Set to ethers.constants.MaxUint256 for max redeem.
-   */
-  public async redeem(recipient: Address, amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.pulp.raw
-      .connect(this._networkConnection.signer!)
-      .redeem(recipient, amount.rawAmount());
-  }
-
-  /**
-   * Redeem PLY from PULP and transfer PLY to msg.sender
-   * @param amount Amount of PULP to be converted to PLY.
-   * Set to ethers.constants.MaxUint256 for max redeem.
-   */
-  public async selfRedeem(amount: TokenAmount): Promise<TransactionResponse> {
-    let msgSender: string = await this._networkConnection.signer!.getAddress();
-    return this.redeem(msgSender, amount);
-  }
-}
-
-export class Papermill extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): PapermillRead {
-    return new PapermillRead(networkConnection);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): PapermillReadWrite {
-    return new PapermillReadWrite(networkConnection);
-  }
-}

package/src/interactors/PlyGame.ts

@@ -1,172 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BigNumber as BN } from 'ethers';
-import * as consts from '../consts';
-import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
-import * as helpers from '../helpers';
-import { getBlocksTimestamp, isSameAddress, sleep, sortEvents } from '../helpers';
-import * as AuriAPI from '../helpers/aurigami-api';
-import {
-  Address,
-  NetworkConnection,
-  PlyBetMadeEvent,
-  PlyGameBetResult,
-  PlyGameLeaderboardItem,
-} from '../types';
-
-export class PlyGameRead extends BlockchainEntityRead {
-  public readonly plyToken: Token;
-  public readonly pulpToken: Token;
-  public readonly env: AuriEnv;
-
-  public constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-
-    let plyAddress = consts.networkAddresses.tokens.PLY;
-    let pulpAddress = consts.networkAddresses.tokens.PULP;
-    this.plyToken = new Token(plyAddress, helpers.getDecimal(plyAddress));
-    this.pulpToken = new Token(pulpAddress, helpers.getDecimal(pulpAddress));
-  }
-
-  private parseBetMakeEvent(event: PlyBetMadeEvent): PlyGameBetResult {
-    let outcome = ['bigWin', 'win', 'lose', 'noImpact'][event.args.outcome];
-    let betAmount = event.args.amount;
-    // 0%, 0%, 100%, 2%
-    // big win, win, lose, no impact
-    let lostAmount = betAmount.mul([0, 0, 100, 2][event.args.outcome]).div(100);
-    let unlock = betAmount.mul([10, 1, 0, 0][event.args.outcome]);
-    return {
-      player: event.args.player,
-      lostAmount: new TokenAmount(this.plyToken, lostAmount.toString()),
-      unlockedPulpAmount: new TokenAmount(this.pulpToken, unlock.toString()),
-      outcome: outcome,
-      transactionHash: event.transactionHash,
-      block: event.blockNumber,
-      timestamp: 0, // will be filled later
-    };
-  }
-
-  private async attachTimestamp(results: PlyGameBetResult[]): Promise<PlyGameBetResult[]> {
-    let blockNumbers = results.map((e) => e.block);
-    let blockstimestamp = await getBlocksTimestamp(this._networkConnection.provider, blockNumbers);
-    return results.map((e, i) => ({ ...e, timestamp: blockstimestamp[i] }));
-  }
-
-  /**
-   * Get 100 most recent bets of the market users
-   */
-  public async getUserPlyGameHistory(user: Address): Promise<PlyGameBetResult[]> {
-    let block100 = await this.env.plygame.callStatic.getLastBlock(user, 100);
-
-    if (block100.eq(0)) {
-      return [];
-    }
-
-    let filter = this.env.plygame.raw.filters.BetMade(user);
-    let events = await this.env.plygame.raw.queryFilter(filter, block100.toNumber());
-    // Sort descending by block number
-    sortEvents(events).reverse();
-    return this.attachTimestamp(events.map((event) => this.parseBetMakeEvent(event)));
-  }
-
-  /**
-   * Get current jackpot amount
-   */
-  public async currentJackpotAmount(): Promise<TokenAmount> {
-    let jackpot = await this.env.plygame.callStatic.currentJackpotAmount();
-    return new TokenAmount(this.plyToken, jackpot.toString());
-  }
-
-  public async earlyUnlockedPulpAmount(user: Address): Promise<TokenAmount> {
-    let earlyUnlockedPulpAmount = await this.env.plygame.callStatic.totalPlyUnlockedEarly(user);
-    return new TokenAmount(this.pulpToken, earlyUnlockedPulpAmount.toString());
-  }
-
-  public async getPlyGameResultsInTransaction(txHash: Address): Promise<PlyGameBetResult[]> {
-    // wait for the tx to be mined if needed.
-    // Don't use `waitForTransaction` because it will wait for longer than needed.
-    let tx = await this._networkConnection.provider.getTransactionReceipt(txHash);
-
-    for (let i = 0; i < 100 && !tx; i++) {
-      await sleep(1000); // Sleep for 1 second before retrying
-      tx = await this._networkConnection.provider.getTransactionReceipt(txHash);
-    }
-
-    if (!tx) {
-      throw new Error(`Transaction ${txHash} takes too long to be mined`);
-    }
-
-    let filter = this.env.plygame.raw.filters.BetMade();
-    let betMadeEvents: PlyBetMadeEvent[] = tx.logs
-      .filter((log) => isSameAddress(log.topics[0], filter.topics![0] as string))
-      .map((log) => ({
-        ...this.env.plygame.raw.interface.parseLog(log),
-        blockNumber: tx.blockNumber,
-        transactionHash: txHash,
-      })) as unknown as PlyBetMadeEvent[];
-
-    return this.attachTimestamp(betMadeEvents.map((e) => this.parseBetMakeEvent(e)));
-  }
-
-  /**
-   * Top 100 users by amount of PULP unlocked
-   */
-  public async leaderboard(): Promise<PlyGameLeaderboardItem[]> {
-    const result = await AuriAPI.getPaginatedApi('/plygame/leaderboard');
-    return result.items.map((item, i) => ({
-      player: item.user!,
-      unlockedPulpAmount: new TokenAmount(this.pulpToken, item.unlockedAmount!),
-      gamesPlayed: item.count!,
-    }));
-  }
-
-  public async getLastJackpotResult(): Promise<{ winner: Address; amount: TokenAmount }> {
-    // 158 is the storage slot of the jackpot length
-    let round = BN.from(
-      await this._networkConnection.provider.getStorageAt(this.env.plygame.address, 158)
-    );
-    let result = await this.env.plygame.callStatic.jackpotHistory(round.sub(1));
-    return {
-      winner: result.winner.slice(0, 5) + '...' + result.winner.slice(-3),
-      amount: new TokenAmount(this.plyToken, result.amount.toString()),
-    };
-  }
-
-  public async overallLeaderboard(): Promise<PlyGameLeaderboardItem[]> {
-    const result = await AuriAPI.getPaginatedApi('/plygame/overallLeaderboard');
-    return result.items.map((item) => ({
-      player: item.user,
-      unlockedPulpAmount: new TokenAmount(this.pulpToken, item.unlockedAmount!),
-      gamesPlayed: item.count!,
-    }));
-  }
-}
-
-export class PlyGameReadWrite extends PlyGameRead {
-  /**
-   * Make a single bet
-   */
-  public async makeBetOnce(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.plygame.raw
-      .connect(this._networkConnection.signer!)
-      .makeBetOnce(amount.rawAmount());
-  }
-
-  public async approve(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.ply.raw
-      .connect(this._networkConnection.signer!)
-      .approve(this.env.plygame.address, amount.rawAmount());
-  }
-}
-
-export class PlyGame extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): PlyGameRead {
-    return new PlyGameRead(networkConnection);
-  }
-  public readWrite(networkConnection: NetworkConnection): PlyGameReadWrite {
-    return new PlyGameReadWrite(networkConnection);
-  }
-}

package/src/interactors/PlyTokenLock.ts

@@ -1,46 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BigNumber as BN } from 'ethers';
-import {
-  AuriEnv,
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYToken,
-  Token,
-  TokenAmount,
-} from '../entities';
-import { Address, NetworkConnection } from '../types';
-
-export class PlyTokenLockRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-
-  public constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  public async getClaimableAmount(recipient: Address): Promise<TokenAmount> {
-    const claimableAmount = await this.env.plyTokenLock.callStatic.claimableBalance(recipient);
-    return new TokenAmount(new Token(PLYToken.address, 18), claimableAmount.toString(), true);
-  }
-}
-
-export class PlyTokenLockReadWrite extends PlyTokenLockRead {
-  public async claim(recipient: Address, amount: TokenAmount): Promise<TransactionResponse> {
-    const amountToClaim = BN.from(amount.rawAmount());
-    return await this.env.plyTokenLock.raw
-      .connect(this._networkConnection.signer!)
-      .claim(recipient, amountToClaim);
-  }
-}
-
-export class PlyTokenLock extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): PlyTokenLockRead {
-    return new PlyTokenLockRead(networkConnection);
-  }
-  public readWrite(networkConnection: NetworkConnection): PlyTokenLockReadWrite {
-    return new PlyTokenLockReadWrite(networkConnection);
-  }
-}

package/src/interactors/Pulp.ts

@@ -1,41 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BigNumber as BN } from 'ethers';
-import { AuriEnv, BlockchainEntity, BlockchainEntityRead, TokenAmount } from '../entities';
-import { Address, NetworkConnection } from '../types';
-
-export class PulpRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-
-  public constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  public async remainingEarlyUnlockPulp(user: Address): Promise<BN> {
-    return this.env.pulp.callStatic.earlyRedeems(user);
-  }
-}
-
-export class PulpReadWrite extends PulpRead {
-  public async convertEarlyPulp(
-    recipient: Address,
-    amount: TokenAmount
-  ): Promise<TransactionResponse> {
-    const amountToRedeem = BN.from(amount.rawAmount());
-    return this.env.pulp.raw
-      .connect(this._networkConnection.signer!)
-      .redeem(recipient, amountToRedeem);
-  }
-}
-
-export class Pulp extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): PulpRead {
-    return new PulpRead(networkConnection);
-  }
-  public readWrite(networkConnection: NetworkConnection): PulpReadWrite {
-    return new PulpReadWrite(networkConnection);
-  }
-}

package/src/interactors/Referral.ts

@@ -1,214 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import axios from 'axios';
-import { ethers } from 'ethers';
-import { AURORA_PLUS_API_PREFIX, REFERRAL_CAMPAIGNS } from '../consts';
-import { AuriEnv, BlockchainEntity, BlockchainEntityRead, TokenAmount } from '../entities';
-import { getBlocksTimestamp } from '../helpers';
-import * as AuriAPI from '../helpers/aurigami-api';
-import { Address, NetworkConnection, ReferralReward } from '../types';
-import { AirdropReadWrite } from './Airdrop';
-
-export class ReferralRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  /**
-   * Generate a 10-character referral code
-   * containing alphanumeric characters.
-   */
-  protected generateReferralCode(): string {
-    let letters = 'abcdefghijklmnopqrstuvwxyz';
-    let numbers = '1234567890';
-    let charset = letters + letters.toUpperCase() + numbers;
-    let R = '';
-    for (var i = 0; i < 10; i++) R += charset[Math.floor(Math.random() * charset.length)];
-    return R;
-  }
-
-  /**
-   * Get the referral code for a given address, returns empty string if not found.
-   *
-   * Called to check if a user has a referral code.
-   */
-  public async getUserReferralCode(userAddr: Address): Promise<string> {
-    const result = await this.env.referralDirectoryV2.raw.userReferralCode(userAddr);
-    return ethers.utils.parseBytes32String(result);
-  }
-
-  /**
-   * Get referral code that a user was referred by, returns empty string if not found.
-   */
-  public async getReferralCodeUsed(userAddr: Address): Promise<string> {
-    const result = await this.env.referralDirectoryV2.raw.referralCodeUsed(userAddr);
-    return ethers.utils.parseBytes32String(result);
-  }
-
-  /**
-   * Get owner of a referral code, returns zero address if not found.
-   */
-  public async getReferralCodeOwner(code: string): Promise<Address> {
-    const referralCode = ethers.utils.formatBytes32String(code);
-    return this.env.referralDirectoryV2.raw.referralCodeOwner(referralCode);
-  }
-
-  /**
-   * Get referrals of a user, sorted descending by timestamp.
-   */
-  public async getReferralsList(userAddr: Address): Promise<{ user: string; timestamp: number }[]> {
-    const result = await AuriAPI.getPaginatedApi('/referral/list', { address: userAddr });
-    const blocks = result.items.map((item) => item.blockNumber!);
-    const blocksTimestamp = await getBlocksTimestamp(this._networkConnection.provider, blocks);
-    const items = result.items.map((item, i) => ({
-      user: item.user!,
-      timestamp: blocksTimestamp[i],
-    }));
-    return items;
-  }
-
-  /**
-   * Array of rewards, sorted by time of the referral period (from latest to oldest)
-   */
-  public async referralRewards(userAddr: Address): Promise<ReferralReward[]> {
-    const result = await AuriAPI.getPaginatedApi('/referral/rewards', { address: userAddr });
-    let items: ReferralReward[] = result.items.map((item, i) => ({
-      campaign: item.campaign!,
-      userAddr: userAddr,
-      isReferrer: (item.campaign as string).includes('referrer'),
-      rewardTokenAmount: TokenAmount.fromAddressAndAmount(item.token, item.amount),
-      startTime: REFERRAL_CAMPAIGNS[item.campaign].start,
-      endTime: REFERRAL_CAMPAIGNS[item.campaign].end,
-      transactionHash: item.transactionHash ?? null,
-      refereeAddress: null,
-    }));
-
-    return items;
-  }
-
-  /**
-   * Top 50 reward earners from the last round, sorted by token amount
-   */
-  public async leaderboard(campaign: string): Promise<ReferralReward[]> {
-    const result = await AuriAPI.getPaginatedApi('/referral/leaderboard', { campaign: campaign });
-    const items: ReferralReward[] = result.items.map((item, i) => ({
-      campaign: campaign,
-      userAddr: item.user!,
-      isReferrer: (item.campaign as string).includes('referrer'),
-      rewardTokenAmount: TokenAmount.fromAddressAndAmount(item.token, item.amount),
-      startTime: REFERRAL_CAMPAIGNS[item.campaign].start,
-      endTime: REFERRAL_CAMPAIGNS[item.campaign].end,
-      transactionHash: null,
-      refereeAddress: null,
-    }));
-    items.sort((a, b) => b.rewardTokenAmount.compare(a.rewardTokenAmount));
-    return items;
-  }
-
-  /**
-   * current number of slots under a referral code being used that exceed minimum deposit amount
-   */
-  public async slotsInUse(): Promise<number> {
-    let result = await AuriAPI.getApi('/referral/slotsInUse');
-    return result;
-  }
-
-  public totalReferralSlots() {
-    return 500;
-  }
-
-  public async queuePosition(address: Address): Promise<number> {
-    let result = await AuriAPI.getApi('/referral/queuePosition', { address: address });
-    return result;
-  }
-
-  /**
-   * a way to determine qualification status of a user. null if not referred yet,
-   * qualified if referred + min deposit, notQualified if referred + min deposit
-   * not reached or withdrew too early
-   */
-  public async userReferralStatus(userAddr: Address): Promise<string> {
-    let result: number = await AuriAPI.getApi('/referral/referralStatus', { address: userAddr });
-    switch (result) {
-      case -1:
-        return 'notReferred';
-      case 0:
-        return 'notQualified';
-      case 1:
-        return 'Qualified';
-      default:
-        return 'Withdrawn';
-    }
-  }
-
-  public async isWhitelistedAddress(address: Address): Promise<boolean> {
-    let result = await this.env.referralDirectoryV2.raw.isUserWhitelisted(address);
-    return result.eq(1);
-  }
-
-  public async isOnAuroraPlus(address: Address): Promise<boolean> {
-    let resp = await axios.get(AURORA_PLUS_API_PREFIX + address);
-
-    return resp.data.status == 'active';
-  }
-
-  public async isNewUserAtReferralTime(address: Address): Promise<boolean> {
-    let result: boolean = await AuriAPI.getApi('/referral/isNewUser', { address: address });
-    return result;
-  }
-
-  public async depositedMoreThanMinimumAmount(address: Address): Promise<boolean> {
-    let result: boolean = await AuriAPI.getApi('/referral/depositedEnough', { address: address });
-    return result;
-  }
-}
-
-export class ReferralReadWrite extends ReferralRead {
-  /**
-   * Generate a referral code for a given address.
-   *
-   * Called when an user want to creates his own referral code
-   */
-  public async registerNewReferralCode(): Promise<TransactionResponse> {
-    const referralCode = ethers.utils.formatBytes32String(this.generateReferralCode());
-    return this.env.referralDirectoryV2.raw
-      .connect(this._networkConnection.signer!)
-      .registerNewUserReferralCode(referralCode);
-  }
-
-  /**
-   * Called when an user confirms he is referred by a specified code
-   */
-  public async useReferralCode(code: string): Promise<TransactionResponse> {
-    const referralCode = ethers.utils.formatBytes32String(code);
-    return this.env.referralDirectoryV2.raw
-      .connect(this._networkConnection.signer!)
-      .registerReferralCodeUsed(referralCode);
-  }
-
-  /**
-   * Claim all unclaimed rewards for a given user
-   */
-  public async claimReferralRewards(): Promise<TransactionResponse> {
-    const unclaimedRewards = (
-      await this.referralRewards(await this._networkConnection.signer!.getAddress())
-    ).filter((reward) => reward.transactionHash == null);
-    const campaigns = unclaimedRewards.map((reward) => reward.campaign);
-    const tokens = unclaimedRewards.map((reward) => reward.rewardTokenAmount.token.address);
-    return new AirdropReadWrite(this._networkConnection).redeemMultiple(campaigns, tokens);
-  }
-}
-
-export class Referral extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): ReferralRead {
-    return new ReferralRead(networkConnection);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): ReferralReadWrite {
-    return new ReferralReadWrite(networkConnection);
-  }
-}