@aurigami/sdk 1.23.1 → 1.24.1

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.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.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.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.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
-      .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
-      .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);
-  }
-}

package/src/interactors/Staking.ts

@@ -1,152 +0,0 @@
-import { IERC20 } from '@aurigami/contracts/typechain';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract } from 'ethers';
-import { EIP20InterfaceABI } from '../abis';
-import * as consts from '../consts';
-import {
-  AuriEnv,
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYWNEARToken,
-  Token,
-  TokenAmount,
-} from '../entities';
-import { calcLMRewardApr, getDecimal } from '../helpers';
-import { fetchValuation } from '../helpers/priceFetcher';
-import { NetworkConnection, PLYWNEARPoolDetails, TokenAPY } from '../types';
-
-export class StakingRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  public async getPLYWNEARPoolDetails(): Promise<PLYWNEARPoolDetails> {
-    const { stakedLiquidity, rewardPerSeconds } = await this.env.auriFairLaunch
-      .getPoolInfo(consts.PLYWNEAR_POOL_ID)
-      .then((res) => {
-        const endedTime = res.endTime;
-        const startTime = res.startTime;
-        const now = Date.now() / 1000;
-        // If the pool has ended or not started, return 0 reward per second
-        if (endedTime < now || startTime > now) {
-          return {
-            stakedLiquidity: res.totalStake,
-            rewardPerSeconds: res.rewardPerSeconds.map((_) => BN.from(0)),
-          };
-        }
-        return { stakedLiquidity: res.totalStake, rewardPerSeconds: res.rewardPerSeconds };
-      });
-
-    let stakedLiquidityAmount = new TokenAmount(PLYWNEARToken, stakedLiquidity!.toString());
-
-    var totalStakeValuation: BigNumber = await fetchValuation(
-      stakedLiquidityAmount,
-      this._networkConnection.provider
-    );
-
-    var promises = [];
-
-    // Calculate the reward per second in USD
-    for (let i = 0; i < rewardPerSeconds!.length; i++) {
-      let rewardTokenAddress = consts.PLYWNEAR_REWARD_TOKENS[i];
-      let rewardToken = new Token(rewardTokenAddress, getDecimal(rewardTokenAddress));
-      let rewardPerSecond = rewardPerSeconds![i];
-      promises.push(
-        fetchValuation(
-          new TokenAmount(rewardToken, rewardPerSecond!.toString()),
-          this._networkConnection.provider
-        )
-      );
-    }
-
-    let APYs: TokenAPY[] = [];
-    (await Promise.all(promises)).forEach((rewardPerSecondValuation, i) => {
-      let rewardTokenAddress = consts.PLYWNEAR_REWARD_TOKENS[i];
-      let apy = calcLMRewardApr(
-        rewardPerSecondValuation,
-        totalStakeValuation,
-        consts.ONE_DAY * 365
-      ).toFixed(consts.DECIMAL_PRECISION);
-
-      APYs.push({
-        address: rewardTokenAddress,
-        apy: apy,
-      });
-    });
-
-    return {
-      totalStakedLiquidity: stakedLiquidityAmount,
-      APYs: APYs,
-    };
-  }
-
-  /**
-   * Get amount of staked LP tokens
-   */
-  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
-    const userInfo = await this.env.auriFairLaunch.getUserInfo(consts.PLYWNEAR_POOL_ID, user);
-    return new TokenAmount(PLYWNEARToken, userInfo.amount.toString());
-  }
-
-  /**
-   * Get amount of LP token in user wallet
-   */
-  public async LpBalanceOf(user: string): Promise<TokenAmount> {
-    let lpContract = new Contract(
-      consts.networkAddresses.tokens.PLYWNEAR,
-      EIP20InterfaceABI.abi,
-      this._networkConnection.provider
-    ) as IERC20;
-    let balance = await lpContract.balanceOf(user);
-
-    return new TokenAmount(PLYWNEARToken, balance.toString());
-  }
-
-  public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
-    let userInfo = await this.env.auriFairLaunch.callStatic.updateAndGetUserInfo(
-      consts.PLYWNEAR_POOL_ID,
-      user,
-      { from: user }
-    );
-
-    let rewards = userInfo.unclaimedRewards;
-    return rewards.map((reward, i) =>
-      TokenAmount.fromAddressAndAmount(consts.PLYWNEAR_REWARD_TOKENS[i], reward.toString())
-    );
-  }
-}
-
-export class StakingReadWrite extends StakingRead {
-  public async stake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.auriFairLaunch
-      .connect(this._networkConnection.signer!)
-      .deposit(consts.PLYWNEAR_POOL_ID, amount.rawAmount());
-  }
-
-  public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
-    const msgSender = await this._networkConnection.signer!.getAddress();
-    const amountInput = BN.from(amount.rawAmount());
-    const stakedAmount = BN.from((await this.stakeBalanceOf(msgSender)).rawAmount());
-    // unstakeAmount = min(amountInput, stakedAmount - 1)
-    const unstakeAmount = amountInput.lt(stakedAmount) ? amountInput : stakedAmount.sub(1);
-    return this.env.auriFairLaunch
-      .connect(this._networkConnection.signer!)
-      .withdraw(consts.PLYWNEAR_POOL_ID, unstakeAmount);
-  }
-}
-
-export class Staking extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): StakingRead {
-    return new StakingRead(networkConnection);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): StakingReadWrite {
-    return new StakingReadWrite(networkConnection);
-  }
-}

package/src/interactors/index.ts

@@ -1,9 +0,0 @@
-export * from './Airdrop';
-export * from './MoneyMarket';
-export * from './Papermill';
-export * from './PlyGame';
-export * from './Pulp';
-export * from './Referral';
-export * from './Staking';
-export * from './misc';
-export * from './PlyTokenLock';