@defisaver/positions-sdk 0.0.201-fluid-dev-9 → 0.0.201-fluid-dev-11

package/src/staking/staking.ts

@@ -9,8 +9,7 @@ import { BLOCKS_IN_A_YEAR, SECONDS_PER_YEAR, AVG_BLOCK_TIME } from '../constants
 import { multicall } from '../multicall';
 import { aprToApy } from '../moneymarket';
 
-
-export const getStETHApy = async (web3: Web3, fromBlock = 17900000, blockNumber: 'latest' | number = 'latest') => {
+const getStETHApy = async (web3: Web3, fromBlock = 17900000, blockNumber: 'latest' | number = 'latest') => {
   try {
     const tokenRebasedEvents: ContractEventLog<{ [key: string]: any }>[] = await LidoContract(web3, NetworkNumber.Eth).getPastEvents('TokenRebased', { fromBlock, toBlock: blockNumber });
     tokenRebasedEvents.sort((a, b) => b.blockNumber - a.blockNumber); // sort from highest to lowest block number
@@ -31,7 +30,7 @@ export const getStETHApy = async (web3: Web3, fromBlock = 17900000, blockNumber:
   }
 };
 
-export const getCbETHApy = async (web3: Web3, blockNumber: 'latest' | number = 'latest') => {
+const getCbETHApy = async (web3: Web3, blockNumber: 'latest' | number = 'latest') => {
   let currentBlock = blockNumber;
   if (blockNumber === 'latest') currentBlock = await web3.eth.getBlockNumber();
   const blockDiff = 6 * 24 * 60 * 60 / AVG_BLOCK_TIME;
@@ -49,7 +48,7 @@ export const getCbETHApy = async (web3: Web3, blockNumber: 'latest' | number = '
 };
 
 
-export const getREthApy = async (web3: Web3, blockNumber: 'latest' | number = 'latest') => {
+const getREthApy = async (web3: Web3, blockNumber: 'latest' | number = 'latest') => {
   let currentBlock = blockNumber;
   if (blockNumber === 'latest') currentBlock = await web3.eth.getBlockNumber();
   const blockDiff = 8 * 24 * 60 * 60 / AVG_BLOCK_TIME;
@@ -67,7 +66,7 @@ export const getREthApy = async (web3: Web3, blockNumber: 'latest' | number = 'l
   return aprToApy(apr);
 };
 
-export const getDsrApy = async (web3: Web3, blockNumber: 'latest' | number = 'latest') => {
+const getDsrApy = async (web3: Web3, blockNumber: 'latest' | number = 'latest') => {
   const potContract = PotContract(web3, NetworkNumber.Eth);
   return new Dec(await potContract.methods.dsr().call())
     .div(new Dec(1e27))
@@ -77,7 +76,7 @@ export const getDsrApy = async (web3: Web3, blockNumber: 'latest' | number = 'la
     .toString();
 };
 
-export const getSsrApy = async () => {
+const getSsrApy = async () => {
   const res = await fetch('https://fe.defisaver.com/api/sky/data');
   const data = await res.json();
   return new Dec(data.data.skyData[0].sky_savings_rate_apy).mul(100).toString();
@@ -104,35 +103,36 @@ const getSuperOETHApy = async () => {
 
 const getApyFromDfsApi = async (asset: string) => {
   const res = await fetch(`https://fe.defisaver.com/api/staking/apy?asset=${asset}`);
+  if (!res.ok) throw new Error(`Failed to fetch APY for ${asset}`);
   const data = await res.json();
   // if our server returns apr, transform it into apy
   if (['weETH'].includes(asset)) {
     return aprToApy(data.apy);
   }
-  return data.apy;
+  return String(data.apy);
 };
 
 export const STAKING_ASSETS = ['cbETH', 'wstETH', 'cbETH', 'rETH', 'sDAI', 'weETH', 'sUSDe', 'osETH', 'ezETH', 'ETHx', 'rsETH', 'pufETH', 'wrsETH', 'wsuperOETHb', 'sUSDS'];
 
-export const getStakingApy = (asset: string, web3: Web3, blockNumber: 'latest' | number = 'latest', fromBlock: number | undefined = undefined) => {
+export const getStakingApy = async (asset: string, web3: Web3, blockNumber: 'latest' | number = 'latest', fromBlock: number | undefined = undefined) => {
   try {
-    if (asset === 'stETH' || asset === 'wstETH') return getStETHApy(web3, fromBlock, blockNumber);
-    if (asset === 'cbETH') return getCbETHApy(web3, blockNumber);
-    if (asset === 'rETH') return getREthApy(web3, blockNumber);
-    if (asset === 'sDAI') return getDsrApy(web3);
-    if (asset === 'sUSDe') return getApyFromDfsApi('sUSDe');
-    if (asset === 'weETH') return getApyFromDfsApi('weETH');
-    if (asset === 'ezETH') return getApyFromDfsApi('ezETH');
-    if (asset === 'osETH') return getApyFromDfsApi('osETH');
-    if (asset === 'ETHx') return getApyFromDfsApi('ETHx');
-    if (asset === 'rsETH' || asset === 'wrsETH') return getApyFromDfsApi('rsETH');
-    if (asset === 'pufETH') return getApyFromDfsApi('pufETH');
-    if (asset === 'wsuperOETHb') return getSuperOETHApy();
-    if (asset === 'sUSDS') return getSsrApy();
+    if (asset === 'stETH' || asset === 'wstETH') return await getStETHApy(web3, fromBlock, blockNumber);
+    if (asset === 'cbETH') return await getCbETHApy(web3, blockNumber);
+    if (asset === 'rETH') return await getREthApy(web3, blockNumber);
+    if (asset === 'sDAI') return await getDsrApy(web3);
+    if (asset === 'sUSDe') return await getApyFromDfsApi('sUSDe');
+    if (asset === 'weETH') return await getApyFromDfsApi('weETH');
+    if (asset === 'ezETH') return await getApyFromDfsApi('ezETH');
+    if (asset === 'osETH') return await getApyFromDfsApi('osETH');
+    if (asset === 'ETHx') return await getApyFromDfsApi('ETHx');
+    if (asset === 'rsETH' || asset === 'wrsETH') return await getApyFromDfsApi('rsETH');
+    if (asset === 'pufETH') return await getApyFromDfsApi('pufETH');
+    if (asset === 'wsuperOETHb') return await getSuperOETHApy();
+    if (asset === 'sUSDS') return await getSsrApy();
   } catch (e) {
     console.error(`Failed to fetch APY for ${asset}`);
-    return '0';
   }
+  return '0';
 };
 
 export const calculateInterestEarned = (principal: string, interest: string, type: string, apy = false) => {

package/src/types/contracts/generated/LiquityV2StabilityPool.ts

@@ -0,0 +1,453 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import type BN from "bn.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type {
+  Callback,
+  PayableTransactionObject,
+  NonPayableTransactionObject,
+  BlockType,
+  ContractEventLog,
+  BaseContract,
+} from "./types";
+
+export interface EventOptions {
+  filter?: object;
+  fromBlock?: BlockType;
+  topics?: string[];
+}
+
+export type ActivePoolAddressChanged = ContractEventLog<{
+  _newActivePoolAddress: string;
+  0: string;
+}>;
+export type B_Updated = ContractEventLog<{
+  _B: string;
+  _epoch: string;
+  _scale: string;
+  0: string;
+  1: string;
+  2: string;
+}>;
+export type BoldTokenAddressChanged = ContractEventLog<{
+  _newBoldTokenAddress: string;
+  0: string;
+}>;
+export type DefaultPoolAddressChanged = ContractEventLog<{
+  _newDefaultPoolAddress: string;
+  0: string;
+}>;
+export type DepositOperation = ContractEventLog<{
+  _depositor: string;
+  _operation: string;
+  _depositLossSinceLastOperation: string;
+  _depositChange: string;
+  _yieldGainSinceLastOperation: string;
+  _yieldGainClaimed: string;
+  _ethGainSinceLastOperation: string;
+  _ethGainClaimed: string;
+  0: string;
+  1: string;
+  2: string;
+  3: string;
+  4: string;
+  5: string;
+  6: string;
+  7: string;
+}>;
+export type DepositUpdated = ContractEventLog<{
+  _depositor: string;
+  _newDeposit: string;
+  _stashedColl: string;
+  _snapshotP: string;
+  _snapshotS: string;
+  _snapshotB: string;
+  _snapshotScale: string;
+  _snapshotEpoch: string;
+  0: string;
+  1: string;
+  2: string;
+  3: string;
+  4: string;
+  5: string;
+  6: string;
+  7: string;
+}>;
+export type EpochUpdated = ContractEventLog<{
+  _currentEpoch: string;
+  0: string;
+}>;
+export type EtherSent = ContractEventLog<{
+  _to: string;
+  _amount: string;
+  0: string;
+  1: string;
+}>;
+export type P_Updated = ContractEventLog<{
+  _P: string;
+  0: string;
+}>;
+export type PriceFeedAddressChanged = ContractEventLog<{
+  _newPriceFeedAddress: string;
+  0: string;
+}>;
+export type S_Updated = ContractEventLog<{
+  _S: string;
+  _epoch: string;
+  _scale: string;
+  0: string;
+  1: string;
+  2: string;
+}>;
+export type ScaleUpdated = ContractEventLog<{
+  _currentScale: string;
+  0: string;
+}>;
+export type StabilityPoolBoldBalanceUpdated = ContractEventLog<{
+  _newBalance: string;
+  0: string;
+}>;
+export type StabilityPoolCollBalanceUpdated = ContractEventLog<{
+  _newBalance: string;
+  0: string;
+}>;
+export type TroveManagerAddressChanged = ContractEventLog<{
+  _newTroveManagerAddress: string;
+  0: string;
+}>;
+
+export interface LiquityV2StabilityPool extends BaseContract {
+  constructor(
+    jsonInterface: any[],
+    address?: string,
+    options?: ContractOptions
+  ): LiquityV2StabilityPool;
+  clone(): LiquityV2StabilityPool;
+  methods: {
+    NAME(): NonPayableTransactionObject<string>;
+
+    P(): NonPayableTransactionObject<string>;
+
+    SCALE_FACTOR(): NonPayableTransactionObject<string>;
+
+    activePool(): NonPayableTransactionObject<string>;
+
+    boldToken(): NonPayableTransactionObject<string>;
+
+    claimAllCollGains(): NonPayableTransactionObject<void>;
+
+    collToken(): NonPayableTransactionObject<string>;
+
+    currentEpoch(): NonPayableTransactionObject<string>;
+
+    currentScale(): NonPayableTransactionObject<string>;
+
+    depositSnapshots(
+      arg0: string
+    ): NonPayableTransactionObject<
+      [string, string, string, string, string] & {
+        S: string;
+        P: string;
+        B: string;
+        scale: string;
+        epoch: string;
+      }
+    >;
+
+    deposits(arg0: string): NonPayableTransactionObject<string>;
+
+    epochToScaleToB(
+      arg0: number | string | BN,
+      arg1: number | string | BN
+    ): NonPayableTransactionObject<string>;
+
+    epochToScaleToS(
+      arg0: number | string | BN,
+      arg1: number | string | BN
+    ): NonPayableTransactionObject<string>;
+
+    getCollBalance(): NonPayableTransactionObject<string>;
+
+    getCompoundedBoldDeposit(
+      _depositor: string
+    ): NonPayableTransactionObject<string>;
+
+    getDepositorCollGain(
+      _depositor: string
+    ): NonPayableTransactionObject<string>;
+
+    getDepositorYieldGain(
+      _depositor: string
+    ): NonPayableTransactionObject<string>;
+
+    getDepositorYieldGainWithPending(
+      _depositor: string
+    ): NonPayableTransactionObject<string>;
+
+    getEntireSystemColl(): NonPayableTransactionObject<string>;
+
+    getEntireSystemDebt(): NonPayableTransactionObject<string>;
+
+    getTotalBoldDeposits(): NonPayableTransactionObject<string>;
+
+    getYieldGainsOwed(): NonPayableTransactionObject<string>;
+
+    getYieldGainsPending(): NonPayableTransactionObject<string>;
+
+    lastBoldLossError_Offset(): NonPayableTransactionObject<string>;
+
+    lastBoldLossError_TotalDeposits(): NonPayableTransactionObject<string>;
+
+    lastCollError_Offset(): NonPayableTransactionObject<string>;
+
+    lastYieldError(): NonPayableTransactionObject<string>;
+
+    offset(
+      _debtToOffset: number | string | BN,
+      _collToAdd: number | string | BN
+    ): NonPayableTransactionObject<void>;
+
+    provideToSP(
+      _topUp: number | string | BN,
+      _doClaim: boolean
+    ): NonPayableTransactionObject<void>;
+
+    stashedColl(arg0: string): NonPayableTransactionObject<string>;
+
+    triggerBoldRewards(
+      _boldYield: number | string | BN
+    ): NonPayableTransactionObject<void>;
+
+    troveManager(): NonPayableTransactionObject<string>;
+
+    withdrawFromSP(
+      _amount: number | string | BN,
+      _doClaim: boolean
+    ): NonPayableTransactionObject<void>;
+  };
+  events: {
+    ActivePoolAddressChanged(
+      cb?: Callback<ActivePoolAddressChanged>
+    ): EventEmitter;
+    ActivePoolAddressChanged(
+      options?: EventOptions,
+      cb?: Callback<ActivePoolAddressChanged>
+    ): EventEmitter;
+
+    B_Updated(cb?: Callback<B_Updated>): EventEmitter;
+    B_Updated(options?: EventOptions, cb?: Callback<B_Updated>): EventEmitter;
+
+    BoldTokenAddressChanged(
+      cb?: Callback<BoldTokenAddressChanged>
+    ): EventEmitter;
+    BoldTokenAddressChanged(
+      options?: EventOptions,
+      cb?: Callback<BoldTokenAddressChanged>
+    ): EventEmitter;
+
+    DefaultPoolAddressChanged(
+      cb?: Callback<DefaultPoolAddressChanged>
+    ): EventEmitter;
+    DefaultPoolAddressChanged(
+      options?: EventOptions,
+      cb?: Callback<DefaultPoolAddressChanged>
+    ): EventEmitter;
+
+    DepositOperation(cb?: Callback<DepositOperation>): EventEmitter;
+    DepositOperation(
+      options?: EventOptions,
+      cb?: Callback<DepositOperation>
+    ): EventEmitter;
+
+    DepositUpdated(cb?: Callback<DepositUpdated>): EventEmitter;
+    DepositUpdated(
+      options?: EventOptions,
+      cb?: Callback<DepositUpdated>
+    ): EventEmitter;
+
+    EpochUpdated(cb?: Callback<EpochUpdated>): EventEmitter;
+    EpochUpdated(
+      options?: EventOptions,
+      cb?: Callback<EpochUpdated>
+    ): EventEmitter;
+
+    EtherSent(cb?: Callback<EtherSent>): EventEmitter;
+    EtherSent(options?: EventOptions, cb?: Callback<EtherSent>): EventEmitter;
+
+    P_Updated(cb?: Callback<P_Updated>): EventEmitter;
+    P_Updated(options?: EventOptions, cb?: Callback<P_Updated>): EventEmitter;
+
+    PriceFeedAddressChanged(
+      cb?: Callback<PriceFeedAddressChanged>
+    ): EventEmitter;
+    PriceFeedAddressChanged(
+      options?: EventOptions,
+      cb?: Callback<PriceFeedAddressChanged>
+    ): EventEmitter;
+
+    S_Updated(cb?: Callback<S_Updated>): EventEmitter;
+    S_Updated(options?: EventOptions, cb?: Callback<S_Updated>): EventEmitter;
+
+    ScaleUpdated(cb?: Callback<ScaleUpdated>): EventEmitter;
+    ScaleUpdated(
+      options?: EventOptions,
+      cb?: Callback<ScaleUpdated>
+    ): EventEmitter;
+
+    StabilityPoolBoldBalanceUpdated(
+      cb?: Callback<StabilityPoolBoldBalanceUpdated>
+    ): EventEmitter;
+    StabilityPoolBoldBalanceUpdated(
+      options?: EventOptions,
+      cb?: Callback<StabilityPoolBoldBalanceUpdated>
+    ): EventEmitter;
+
+    StabilityPoolCollBalanceUpdated(
+      cb?: Callback<StabilityPoolCollBalanceUpdated>
+    ): EventEmitter;
+    StabilityPoolCollBalanceUpdated(
+      options?: EventOptions,
+      cb?: Callback<StabilityPoolCollBalanceUpdated>
+    ): EventEmitter;
+
+    TroveManagerAddressChanged(
+      cb?: Callback<TroveManagerAddressChanged>
+    ): EventEmitter;
+    TroveManagerAddressChanged(
+      options?: EventOptions,
+      cb?: Callback<TroveManagerAddressChanged>
+    ): EventEmitter;
+
+    allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+  };
+
+  once(
+    event: "ActivePoolAddressChanged",
+    cb: Callback<ActivePoolAddressChanged>
+  ): void;
+  once(
+    event: "ActivePoolAddressChanged",
+    options: EventOptions,
+    cb: Callback<ActivePoolAddressChanged>
+  ): void;
+
+  once(event: "B_Updated", cb: Callback<B_Updated>): void;
+  once(
+    event: "B_Updated",
+    options: EventOptions,
+    cb: Callback<B_Updated>
+  ): void;
+
+  once(
+    event: "BoldTokenAddressChanged",
+    cb: Callback<BoldTokenAddressChanged>
+  ): void;
+  once(
+    event: "BoldTokenAddressChanged",
+    options: EventOptions,
+    cb: Callback<BoldTokenAddressChanged>
+  ): void;
+
+  once(
+    event: "DefaultPoolAddressChanged",
+    cb: Callback<DefaultPoolAddressChanged>
+  ): void;
+  once(
+    event: "DefaultPoolAddressChanged",
+    options: EventOptions,
+    cb: Callback<DefaultPoolAddressChanged>
+  ): void;
+
+  once(event: "DepositOperation", cb: Callback<DepositOperation>): void;
+  once(
+    event: "DepositOperation",
+    options: EventOptions,
+    cb: Callback<DepositOperation>
+  ): void;
+
+  once(event: "DepositUpdated", cb: Callback<DepositUpdated>): void;
+  once(
+    event: "DepositUpdated",
+    options: EventOptions,
+    cb: Callback<DepositUpdated>
+  ): void;
+
+  once(event: "EpochUpdated", cb: Callback<EpochUpdated>): void;
+  once(
+    event: "EpochUpdated",
+    options: EventOptions,
+    cb: Callback<EpochUpdated>
+  ): void;
+
+  once(event: "EtherSent", cb: Callback<EtherSent>): void;
+  once(
+    event: "EtherSent",
+    options: EventOptions,
+    cb: Callback<EtherSent>
+  ): void;
+
+  once(event: "P_Updated", cb: Callback<P_Updated>): void;
+  once(
+    event: "P_Updated",
+    options: EventOptions,
+    cb: Callback<P_Updated>
+  ): void;
+
+  once(
+    event: "PriceFeedAddressChanged",
+    cb: Callback<PriceFeedAddressChanged>
+  ): void;
+  once(
+    event: "PriceFeedAddressChanged",
+    options: EventOptions,
+    cb: Callback<PriceFeedAddressChanged>
+  ): void;
+
+  once(event: "S_Updated", cb: Callback<S_Updated>): void;
+  once(
+    event: "S_Updated",
+    options: EventOptions,
+    cb: Callback<S_Updated>
+  ): void;
+
+  once(event: "ScaleUpdated", cb: Callback<ScaleUpdated>): void;
+  once(
+    event: "ScaleUpdated",
+    options: EventOptions,
+    cb: Callback<ScaleUpdated>
+  ): void;
+
+  once(
+    event: "StabilityPoolBoldBalanceUpdated",
+    cb: Callback<StabilityPoolBoldBalanceUpdated>
+  ): void;
+  once(
+    event: "StabilityPoolBoldBalanceUpdated",
+    options: EventOptions,
+    cb: Callback<StabilityPoolBoldBalanceUpdated>
+  ): void;
+
+  once(
+    event: "StabilityPoolCollBalanceUpdated",
+    cb: Callback<StabilityPoolCollBalanceUpdated>
+  ): void;
+  once(
+    event: "StabilityPoolCollBalanceUpdated",
+    options: EventOptions,
+    cb: Callback<StabilityPoolCollBalanceUpdated>
+  ): void;
+
+  once(
+    event: "TroveManagerAddressChanged",
+    cb: Callback<TroveManagerAddressChanged>
+  ): void;
+  once(
+    event: "TroveManagerAddressChanged",
+    options: EventOptions,
+    cb: Callback<TroveManagerAddressChanged>
+  ): void;
+}