@aurigami/sdk 1.23.1 → 1.24.1

package/src/interactors/Multicall.ts

@@ -1,50 +0,0 @@
-import { Multicall2 } from '@aurigami/contracts/typechain';
-import { Contract, ethers } from 'ethers';
-import { Result } from 'ethers/lib/utils';
-import * as abis from '../abis';
-import * as consts from '../consts';
-import { BlockchainEntityRead } from '../entities';
-import { NetworkConnection } from '../types';
-
-export class MulticallRead extends BlockchainEntityRead {
-  public readonly multicall: Multicall2;
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.multicall = new Contract(
-      consts.networkAddresses.misc.MULTICALL,
-      abis.Multicall2ABI.abi,
-      networkConnection.provider
-    ) as Multicall2;
-  }
-
-  /**
-   * Run multiple calls via multicall contract
-   */
-  public async aggregate(
-    calls: {
-      contract: Contract;
-      method: string;
-      args: any[];
-      returnTypes: string[];
-    }[]
-  ): Promise<Result[]> {
-    const txns = [];
-    // prepare transactions
-    for (let i = 0; i < calls.length; i++) {
-      const call = calls[i];
-      let txn = await call.contract.populateTransaction[call.method](...call.args);
-      txns.push({ target: txn.to!, callData: txn.data! });
-    }
-
-    const response = await this.multicall.callStatic.aggregate(txns);
-
-    // parse results
-    const decodedReturn = [];
-    for (let i = 0; i < calls.length; i++) {
-      decodedReturn.push(
-        ethers.utils.defaultAbiCoder.decode(calls[i].returnTypes, response.returnData[i])
-      );
-    }
-    return decodedReturn;
-  }
-}

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.balanceOf(userAddress);
-    return new TokenAmount(this.plyToken, plyBalance.toString());
-  }
-
-  public async getPulpBalance(userAddress: Address): Promise<TokenAmount> {
-    const pulpBalance = await this.env.pulp.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.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.getPercentLock(this.env.pulp.address, userAddress, currentWeek),
-      this.env.auriLens.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.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.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.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
-      .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.getLastBlock(user, 100);
-
-    if (block100.eq(0)) {
-      return [];
-    }
-
-    let filter = this.env.plygame.filters.BetMade(user);
-    let events = await this.env.plygame.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.currentJackpotAmount();
-    return new TokenAmount(this.plyToken, jackpot.toString());
-  }
-
-  public async earlyUnlockedPulpAmount(user: Address): Promise<TokenAmount> {
-    let earlyUnlockedPulpAmount = await this.env.plygame.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.filters.BetMade();
-    let betMadeEvents: PlyBetMadeEvent[] = tx.logs
-      .filter((log) => isSameAddress(log.topics[0], filter.topics![0] as string))
-      .map((log) => ({
-        ...this.env.plygame.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.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
-      .connect(this._networkConnection.signer!)
-      .makeBetOnce(amount.rawAmount());
-  }
-
-  public async approve(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.ply
-      .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,47 +0,0 @@
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BigNumber as BN, utils } from 'ethers';
-import {
-  AuriEnv,
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYToken,
-  Token,
-  TokenAmount,
-} from '../entities';
-import * as helpers from '../helpers';
-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
-      .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,39 +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.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.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);
-  }
-}