@aurigami/sdk 1.12.9-hf → 1.13.0

package/dist/types/index.d.ts

@@ -163,3 +163,8 @@ export declare type PlyBetMadeEvent = TypedEvent<[string, BN, number] & {
     amount: BN;
     outcome: number;
 }>;
+export declare type Apy = {
+    sum: BigNumber;
+    suppliedValue: BigNumber;
+    borrowedValue: BigNumber;
+};

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.12.9-hf",
+    "version": "1.13.0",
     "license": "MIT",
     "main": "dist/index.js",
     "typings": "dist/index.d.ts",

package/src/SDK.ts

@@ -91,6 +91,16 @@ export class SdkRead extends BlockchainEntityRead {
   ): Promise<types.AccountAuTokensInfo[]> {
     return this._misc.sneakAccounts(accounts, tokenAddresses, dust);
   }
+
+  public async getNetApyWithoutIncentive(userAddress: types.Address): Promise<BigNumber> {
+    const miscRead = new MiscRead(this._networkConnection);
+    return miscRead.getNetApyWithoutIncentive(userAddress);
+  }
+
+  public async getNetApyWithIncentive(userAddress: types.Address): Promise<BigNumber> {
+    const miscRead = new MiscRead(this._networkConnection);
+    return miscRead.getNetApyWithIncentive(userAddress);
+  }
 }
 
 export class SdkReadWrite extends SdkRead {

package/src/consts/constants.ts

@@ -184,3 +184,5 @@ export const REFERRAL_CAMPAIGNS: { [k: string]: { start: number; end: number } }
     ['referral-1506', { start: 1654696800, end: 1655301599 }],
     ['referrer-1506', { start: 1654696800, end: 1655301599 }],
   ]);
+
+export const CACHE_TIMEOUT = 10 * 1000; // 10 seconds

package/src/helpers/helpers.ts

@@ -3,7 +3,7 @@ import { Provider } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
 import { BigNumber as BN, utils } from 'ethers';
 import { Result } from 'ethers/lib/utils';
-import { networkAddresses } from '../consts/constants';
+import { CACHE_TIMEOUT, networkAddresses } from '../consts/constants';
 import { decimalRecords } from '../consts/decimals';
 import { symbolRecords } from '../consts/symbols';
 import { Address } from '../types';
@@ -83,6 +83,15 @@ export function calcLMRewardApr(
   return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
 }
 
+export function calcNetApy(
+  suppliedValue: BigNumber,
+  supplyApy: BigNumber,
+  borrowedValue: BigNumber,
+  borrowApy: BigNumber
+) {
+  return suppliedValue.multipliedBy(supplyApy).minus(borrowedValue.multipliedBy(borrowApy));
+}
+
 export async function getBlockTimestamp(provider: Provider, blockNumber: number): Promise<number> {
   const block = await provider.getBlock(blockNumber);
   return block.timestamp;
@@ -181,3 +190,23 @@ export function sortEvents<T extends Result>(events: TypedEvent<T>[]): TypedEven
     return a.blockNumber - b.blockNumber;
   });
 }
+
+export function Cache(cacheTimeout: number) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+    let cache = new Map<string, any>();
+    descriptor.value = function (...args: any[]) {
+      let key = JSON.stringify(args);
+      if (cache.has(key)) {
+        let [timestamp, value] = cache.get(key);
+        if (Date.now() - timestamp < cacheTimeout) {
+          return value;
+        }
+      }
+      let result = originalMethod.apply(this, args);
+      cache.set(key, [Date.now(), result]);
+      return result;
+    };
+    return descriptor;
+  };
+}

package/src/helpers/priceFetcher.ts

@@ -81,19 +81,19 @@ export async function fetchLPPositions(
   totalSupply: BN;
 }> {
   const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider) as IUniswapV2Pair;
-  var promises: any[] = [];
-  promises.push(LPContract.token0());
-  promises.push(LPContract.token1());
-  promises.push(LPContract.getReserves());
-  promises.push(LPContract.totalSupply());
-  const values: any[] = await Promise.all(promises);
+  const [token0, token1, reserves, totalSupply] = await Promise.all([
+    LPContract.token0(),
+    LPContract.token1(),
+    LPContract.getReserves(),
+    LPContract.totalSupply(),
+  ]);
 
   return {
-    token0: values[0] as string,
-    token1: values[1] as string,
-    reserve0: (values[2] as { reserve0: BN; reserve1: BN }).reserve0,
-    reserve1: (values[2] as { reserve0: BN; reserve1: BN }).reserve1,
-    totalSupply: values[3] as BN,
+    token0: token0,
+    token1: token1,
+    reserve0: reserves.reserve0,
+    reserve1: reserves.reserve1,
+    totalSupply: totalSupply,
   };
 }
 

package/src/interactors/MoneyMarket.ts

@@ -4,7 +4,7 @@ import BigNumber from 'bignumber.js';
 import { BigNumber as BN, Contract } from 'ethers';
 import * as abis from '../abis';
 import * as consts from '../consts';
-import { ONE_DAY } from '../consts';
+import { CACHE_TIMEOUT, ONE_DAY } from '../consts';
 import {
   AuriEnv,
   BlockchainEntity,
@@ -15,7 +15,14 @@ import {
 } from '../entities';
 import * as helpers from '../helpers';
 import { calcValuation, fetchPrice, fetchValuation } from '../helpers/priceFetcher';
-import { Address, ComptrollerRewardType, MoneyMarketDetails, NetworkConnection } from '../types';
+import {
+  Address,
+  Apy,
+  ComptrollerRewardType,
+  MoneyMarketDetails,
+  NetworkConnection,
+} from '../types';
+import { Cache } from '../helpers/helpers';
 
 type RewardSpeeds = {
   plyRewardSupplySpeed: BN;
@@ -43,6 +50,17 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     this.underlying = new Token(underlyingAsset, helpers.getDecimal(underlyingAsset));
   }
 
+  @Cache(CACHE_TIMEOUT)
+  public async getUnderlyingPrice(): Promise<BigNumber> {
+    return fetchPrice(this.underlying.address, this._networkConnection.provider);
+  }
+
+  @Cache(CACHE_TIMEOUT)
+  public async getPlyPrice(): Promise<BigNumber> {
+    return fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider);
+  }
+
+  @Cache(CACHE_TIMEOUT)
   protected async getRewardSpeeds(): Promise<RewardSpeeds> {
     var speeds = await this.env.auriLens.getRewardSpeeds(
       this.env.comptroller.address,
@@ -50,29 +68,27 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     );
     return speeds;
   }
+
+  @Cache(CACHE_TIMEOUT)
   public async getTotalTokenBorrowed(): Promise<TokenAmount> {
     return new TokenAmount(this.underlying, (await this.auToken.totalBorrows()).toString());
   }
+
+  @Cache(CACHE_TIMEOUT)
   public async getTotalTokenDeposited(): Promise<TokenAmount> {
-    var promises = [];
-    var totalBorrow: TokenAmount, totalCash: TokenAmount;
-    promises.push(
-      this.getTotalTokenBorrowed().then((res: TokenAmount) => {
-        totalBorrow = res;
-      })
-    );
-    promises.push(
-      this.auToken.getCash().then((res: BN) => {
-        totalCash = new TokenAmount(this.underlying, res.toString());
-      })
-    );
-    await Promise.all(promises);
+    const [totalBorrow, totalCash] = await Promise.all([
+      this.getTotalTokenBorrowed(),
+      this.auToken.getCash(),
+    ]);
     return new TokenAmount(
       this.underlying,
-      BN.from(totalCash!.rawAmount()).add(totalBorrow!.rawAmount()).toString()
+      BN.from(new TokenAmount(this.underlying, totalCash.toString()).rawAmount())
+        .add(totalBorrow.rawAmount())
+        .toString()
     );
   }
 
+  @Cache(CACHE_TIMEOUT)
   public async getDepositAPY(): Promise<BigNumber> {
     const supplyRatePerTimestamp = await this.auToken.supplyRatePerTimestamp();
     const supplyRatePerDay = new BigNumber(supplyRatePerTimestamp.toString())
@@ -82,6 +98,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     return new BigNumber(supplyRatePerDay.plus(1)).pow(365).minus(1);
   }
 
+  @Cache(CACHE_TIMEOUT)
   public async getBorrowAPY(): Promise<BigNumber> {
     const borrowRatePerTimestamp = await this.auToken.borrowRatePerTimestamp();
     const borrowRatePerDay = new BigNumber(borrowRatePerTimestamp.toString())
@@ -90,202 +107,137 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     return new BigNumber(borrowRatePerDay.plus(1)).pow(365).minus(1);
   }
 
+  @Cache(CACHE_TIMEOUT)
   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(CACHE_TIMEOUT)
   public async getBorrowPlyAPY(): Promise<BigNumber> {
-    var promises = [];
-    var totalBorrowed: TokenAmount,
-      rewardSpeed: TokenAmount,
-      plyPrice: BigNumber,
-      underlyingPrice: BigNumber;
-    promises.push(
-      this.getTotalTokenBorrowed().then((res: TokenAmount) => {
-        totalBorrowed = res;
-      })
-    );
-    promises.push(
-      this.env.comptroller
-        .rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address, false)
-        .then((res) => {
-          rewardSpeed = new TokenAmount(PLYToken, res.toString());
-        })
-    );
-    promises.push(
-      fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider).then(
-        (res) => {
-          plyPrice = res;
-        }
-      )
-    );
-    promises.push(
-      fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {
-        underlyingPrice = res;
-      })
-    );
-    await Promise.all(promises);
+    const [totalBorrowed, rewardSpeeds, plyPrice, underlyingPrice] = await Promise.all([
+      this.getTotalTokenBorrowed(),
+      this.getRewardSpeeds(),
+      this.getPlyPrice(),
+      this.getUnderlyingPrice(),
+    ]);
     return helpers.calcLMRewardApr(
-      plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
-      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
+      calcValuation(
+        new TokenAmount(PLYToken, rewardSpeeds.plyRewardBorrowSpeed.toString()),
+        plyPrice
+      ),
+      underlyingPrice.multipliedBy(totalBorrowed.formattedAmount()),
       consts.ONE_YEAR
     );
   }
 
+  @Cache(CACHE_TIMEOUT)
   public async getDepositPlyAPY(): Promise<BigNumber> {
-    var promises = [];
-    var totalDeposited: TokenAmount,
-      rewardSpeed: TokenAmount,
-      plyPrice: BigNumber,
-      underlyingPrice: BigNumber;
-    promises.push(
-      this.getTotalTokenDeposited().then((res: TokenAmount) => {
-        totalDeposited = res;
-      })
-    );
-    promises.push(
-      this.env.comptroller
-        .rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address, true)
-        .then((res) => {
-          rewardSpeed = new TokenAmount(PLYToken, res.toString());
-        })
-    );
-    promises.push(
-      fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider).then(
-        (res) => {
-          plyPrice = res;
-        }
-      )
-    );
-    promises.push(
-      fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {
-        underlyingPrice = res;
-      })
-    );
-    await Promise.all(promises);
+    const [totalDeposited, rewardSpeeds, plyPrice, underlyingPrice] = await Promise.all([
+      this.getTotalTokenDeposited(),
+      this.getRewardSpeeds(),
+      this.getPlyPrice(),
+      this.getUnderlyingPrice(),
+    ]);
     return helpers.calcLMRewardApr(
-      plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
-      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
-      consts.ONE_YEAR
-    );
-  }
-  public async getDetails(): Promise<MoneyMarketDetails> {
-    var promises = [],
-      totalDeposited: TokenAmount,
-      totalBorrowed: TokenAmount,
-      depositAPY: number,
-      borrowAPY: number,
-      collateralRatio: number;
-    promises.push(
-      this.getTotalTokenDeposited().then((res: TokenAmount) => {
-        totalDeposited = res;
-      })
-    );
-    promises.push(
-      this.getTotalTokenBorrowed().then((res: TokenAmount) => {
-        totalBorrowed = res;
-      })
-    );
-    promises.push(
-      this.getDepositAPY().then((res: BigNumber) => {
-        depositAPY = res.toNumber();
-      })
-    );
-    promises.push(
-      this.getBorrowAPY().then((res: BigNumber) => {
-        borrowAPY = res.toNumber();
-      })
-    );
-    promises.push(
-      this.getCollateralRatio().then((res: BigNumber) => {
-        collateralRatio = res.toNumber();
-      })
-    );
-
-    var plyPrice: BigNumber, underlyingPrice: BigNumber, rewardSpeeds: RewardSpeeds;
-    promises.push(
-      this.getRewardSpeeds().then((res) => {
-        rewardSpeeds = res;
-      })
-    );
-    promises.push(
-      fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider).then(
-        (res) => {
-          plyPrice = res;
-        }
-      )
-    );
-    promises.push(
-      fetchPrice(this.underlying.address, this._networkConnection.provider).then((res) => {
-        underlyingPrice = res;
-      })
-    );
-
-    await Promise.all(promises);
-
-    var borrowPlyApy = helpers.calcLMRewardApr(
       calcValuation(
-        new TokenAmount(PLYToken, rewardSpeeds!.plyRewardBorrowSpeed.toString()),
-        plyPrice!
+        new TokenAmount(PLYToken, rewardSpeeds.plyRewardSupplySpeed.toString()),
+        plyPrice
       ),
-      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
-      consts.ONE_YEAR
-    );
-    var depositPlyApy = helpers.calcLMRewardApr(
-      calcValuation(
-        new TokenAmount(PLYToken, rewardSpeeds!.plyRewardSupplySpeed.toString()),
-        plyPrice!
-      ),
-      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
+      underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
       consts.ONE_YEAR
     );
+  }
 
-    var depositNEARApy = helpers.calcLMRewardApr(
+  @Cache(CACHE_TIMEOUT)
+  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()),
+      underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
       52
     );
-    var borrowNEARApy = helpers.calcLMRewardApr(
+    return depositNEARApy;
+  }
+
+  @Cache(CACHE_TIMEOUT)
+  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()),
+      underlyingPrice.multipliedBy(totalBorrowed.formattedAmount()),
       52
     );
-    var depositMETAApy;
+    return borrowNEARApy;
+  }
+
+  @Cache(CACHE_TIMEOUT)
+  public async getDepositMetaAPY(): Promise<BigNumber> {
+    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, '1250000', false),
           this._networkConnection.provider
         ),
-        underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
+        underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
         12
       );
     } else {
       depositMETAApy = new BigNumber(0);
     }
+    return depositMETAApy;
+  }
 
+  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] =
+      await Promise.all([
+        this.getDepositPlyAPY(),
+        this.getBorrowPlyAPY(),
+        this.getDepositNearAPY(),
+        this.getBorrowNearAPY(),
+        this.getDepositMetaAPY(),
+      ]);
     return {
       auTokenAddress: this.auToken.address,
-      totalTokenDeposited: totalDeposited!,
-      totalTokenBorrowed: totalBorrowed!,
-      depositApy: depositAPY!,
-      depositPlyApy: depositPlyApy.toNumber(),
-      borrowApy: borrowAPY!,
-      borrowPlyApy: borrowPlyApy.toNumber() * -1,
-      collateralRatio: collateralRatio!,
+      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()
+        rewardSpeeds.plyRewardSupplySpeed.mul(consts.ONE_DAY).mul(7).toString()
       ),
       borrowPlyPerWeek: new TokenAmount(
         PLYToken,
-        rewardSpeeds!.plyRewardBorrowSpeed.mul(consts.ONE_DAY).mul(7).toString()
+        rewardSpeeds.plyRewardBorrowSpeed.mul(consts.ONE_DAY).mul(7).toString()
       ),
-      depositNEARApy: depositNEARApy.toNumber(),
-      borrowNEARApy: borrowNEARApy.toNumber() * -1,
-      depositMETAApy: depositMETAApy.toNumber(),
+      depositNEARApy: depositNearAPY.toNumber(),
+      borrowNEARApy: borrowNearAPY.toNumber() * -1,
+      depositMETAApy: depositMetaAPY.toNumber(),
     };
   }
 
@@ -344,6 +296,63 @@ export class MoneyMarketRead extends BlockchainEntityRead {
       (await this.env.comptroller.borrowCaps(this.auToken.address)).toString()
     );
   }
+
+  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(),
+    ]);
+    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
+    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
+    const totalDepositApy = depositApy
+      .plus(nearDepositApy)
+      .plus(plyDepositApy)
+      .plus(metaDepositApy);
+    const totalBorrowApy = borrowApy.plus(nearBorrowApy).plus(plyBorrowApy);
+    const sum = helpers.calcNetApy(suppliedValue, totalDepositApy, borrowedValue, totalBorrowApy);
+    return {
+      sum,
+      suppliedValue,
+      borrowedValue,
+    };
+  }
 }
 
 export class MoneyMarketReadWrite extends MoneyMarketRead {

package/src/interactors/Papermill.ts

@@ -58,17 +58,12 @@ export class PapermillRead extends BlockchainEntityRead {
    */
   public async getLockingDetails(userAddress: Address): Promise<UserLockingDetails> {
     const currentWeek = this.getWeek(helpers.getCurrentTimestamp());
-    var promises: any[] = [];
 
-    promises.push(
-      this.env.auriLens.getPercentLock(this.env.pulp.address, userAddress, currentWeek)
-    );
-    promises.push(
-      this.env.auriLens.getPercentLock(this.env.pulp.address, userAddress, currentWeek + 1)
-    );
-    promises.push(this.getUnclaimedPlyReward(userAddress));
-
-    var values: any[] = await Promise.all(promises);
+    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]);

package/src/interactors/PlyGame.ts

@@ -10,7 +10,7 @@ import {
   NetworkConnection,
   PlyBetMadeEvent,
   PlyGameBetResult,
-  PlyGameLeaderboardItem
+  PlyGameLeaderboardItem,
 } from '../types';
 
 export class PlyGameRead extends BlockchainEntityRead {
@@ -131,15 +131,6 @@ export class PlyGameRead extends BlockchainEntityRead {
       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 {