@aurigami/sdk 0.1.6 → 0.2.3

package/src/MoneyMarket.ts

@@ -1,73 +1,204 @@
 import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
-import { ProviderOrSigner, MoneyMarketDetails } from './types';
-import {
-  validateAndParseAddress,
-  Address,
-  CurrencyAmount,
-} from '@pendle/sdk-core';
-import { Contract } from 'ethers';
-import AuToken from '@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json';
-import IERC20 from '@aurigami/contracts/artifacts/contracts/EIP20Interface.sol/EIP20Interface.json';
+import { MoneyMarketDetails, NetworkConnection, Address, ComptrollerRewardType } from './types';
+import { Contract, BigNumber as BN } from 'ethers';
+import AuErc20ABI from '@aurigami/contracts/artifacts/contracts/AuErc20.sol/AuErc20.json';
+import AuETHABI from '@aurigami/contracts/artifacts/contracts/AuETH.sol/AuETH.json';
+import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
+import { AuErc20, AuETH, Comptroller } from "@aurigami/contracts/typechain";
 import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { dummyToken, dummyTokenAmount, dummyTokenAmount2 } from './dummy';
+import { networkAddresses, ETHAddress } from "./constants";
+import BigNumber from "bignumber.js";
+import { decimalFactor, isSameAddress } from './helpers';
+import { Token } from './token';
+import { TokenAmount } from './tokenAmount';
+import { getDecimal, validateAndParseAddress } from './helpers';
+import { calcLMRewardApr, DECIMAL_PRECISION, fetchPrice, fetchPriceFromCoingecko, ONE_YEAR, PLYToken } from '.';
 
 export class MoneyMarketRead extends BlockchainEntityRead {
-  protected _auToken: Contract;
-  constructor(providerOrSigner: ProviderOrSigner, auToken: Address) {
-    super(providerOrSigner);
-    this._auToken = new Contract(auToken, AuToken.abi, providerOrSigner);
+  public underlying: Token;
+  public auToken: AuErc20 | AuETH;
+  protected _comptroller: Comptroller;
+  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
+    super(networkConnection);
+    if (isSameAddress(underlyingAsset, ETHAddress)) {
+      this.auToken = new Contract(auToken, AuETHABI.abi, networkConnection.provider) as AuETH
+    } else {
+      this.auToken = new Contract(auToken, AuErc20ABI.abi, networkConnection.provider) as AuErc20;
+    }
+    this.underlying = new Token( 
+      underlyingAsset,
+      getDecimal(underlyingAsset),
+    );
+    this._comptroller = new Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider) as Comptroller;
+  }
+
+  public async getTotalTokenBorrowed(): Promise<TokenAmount> {
+    return new TokenAmount(
+      this.underlying,
+      (await this.auToken.totalBorrows()).toString()
+    )
+  }
+  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);
+    return new TokenAmount(
+      this.underlying,
+      BN.from(totalCash!.rawAmount).add(totalBorrow!.rawAmount()).toString()
+    )
+  }
+
+  public async getDepositAPY(): Promise<BigNumber> {
+    const supplyRatePerTimestamp = await this.auToken.supplyRatePerTimestamp();
+    return new BigNumber(supplyRatePerTimestamp.toString()).multipliedBy(60*60*24*365).div(decimalFactor(18));
+  }
+
+  public async getBorrowAPY(): Promise<BigNumber> {
+    const borrowRatePerTimestamp = await this.auToken.borrowRatePerTimestamp();
+    return new BigNumber(borrowRatePerTimestamp.toString()).multipliedBy(60*60*24*365).div(decimalFactor(18));
+  }
+
+  public async getCollateralRatio(): Promise<BigNumber> {
+    return this._comptroller.markets(this.auToken.address).then((res: any) => {
+      return new BigNumber(res.collateralFactorMantissa.toString()).div(decimalFactor(18));
+    })
+  }
+
+  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._comptroller.rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address).then((res) => {
+      rewardSpeed = new TokenAmount(
+        PLYToken,
+        res.toString()
+      )
+    }));
+    promises.push(fetchPrice(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);
+    return calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+    underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()), ONE_YEAR);
+  }
+
+  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._comptroller.rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address).then((res) => {
+      rewardSpeed = new TokenAmount(
+        PLYToken,
+        res.toString()
+      )
+    }));
+    promises.push(fetchPrice(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);
+    return calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+    underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()), 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 rewardSpeed: TokenAmount, plyPrice: BigNumber, underlyingPrice: BigNumber;
+    promises.push(this._comptroller.rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address).then((res) => {
+      rewardSpeed = new TokenAmount(
+        PLYToken,
+        res.toString()
+      )
+    }));
+    promises.push(fetchPrice(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 = calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()), ONE_YEAR);
+    var depositPlyApy = calcLMRewardApr(plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()), ONE_YEAR);
+
     return {
-      auTokenAddress: '0x1111111111111111111111111111111111111111',
-      totalTokenDeposited: dummyTokenAmount,
-      totalTokenBorrowed: dummyTokenAmount2,
-      depositApy: 0.1234,
-      depositPlyApy: 0.2345,
-      borrowApy: 0.24,
-      borrowPlyApy: 0.18,
-      collateralRatio: 0.7,
+      auTokenAddress: this.auToken.address,
+      totalTokenDeposited: totalDeposited!,
+      totalTokenBorrowed: totalBorrowed!,
+      depositApy: depositAPY!,
+      depositPlyApy: depositPlyApy.toNumber(), 
+      borrowApy: borrowAPY!,
+      borrowPlyApy: borrowPlyApy.toNumber(), 
+      collateralRatio: collateralRatio!
     };
   }
+
+  public async getUserBorrowBalance(userAddress: string): Promise<TokenAmount> {
+    const totalBorrow: BN = await this.auToken.callStatic.borrowBalanceCurrent(userAddress);
+    return new TokenAmount(
+      this.underlying,
+      totalBorrow.toString()
+    )
+  }
+
+  public async getUserDepositBalance(userAddress: string): Promise<TokenAmount> {
+    const totalDeposit: BN = await this.auToken.callStatic.balanceOfUnderlying(userAddress);
+    return new TokenAmount(
+      this.underlying,
+      totalDeposit.toString()
+    )
+  }
+
+  
 }
 
 export class MoneyMarketReadWrite extends MoneyMarketRead {
-  dummyTransaction = async (): Promise<TransactionResponse> => {
-    // const dummyErc20Token = new Contract(
-    //   dummyToken.address,
-    //   IERC20.abi,
-    //   this._providerOrSigner
-    // );
-    // return await dummyErc20Token.approve(dummyToken.address, 123);
-    return {} as TransactionResponse;
-  };
-  public async deposit(amount: CurrencyAmount): Promise<TransactionResponse> {
-    return this.dummyTransaction();
-  }
-  public async borrow(amount: CurrencyAmount): Promise<TransactionResponse> {
-    return this.dummyTransaction();
-  }
-  public async withdraw(amount: CurrencyAmount): Promise<TransactionResponse> {
-    return this.dummyTransaction();
-  }
-  public async repay(amount: CurrencyAmount): Promise<TransactionResponse> {
-    return this.dummyTransaction();
+  public async deposit(amount: TokenAmount): Promise<TransactionResponse> {
+    if (isSameAddress(amount.token.address, ETHAddress)) {
+      return (this.auToken as AuETH).connect(this._networkConnection.signer!).mint({value: amount.rawAmount()});
+    } else {
+      return (this.auToken as AuErc20).connect(this._networkConnection.signer!).mint(amount.rawAmount());
+    }
+  }
+  public async borrow(amount: TokenAmount): Promise<TransactionResponse> {
+    return this.auToken.connect(this._networkConnection.signer!).borrow(amount.rawAmount());
+  }
+  public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
+    return this.auToken.connect(this._networkConnection.signer!).redeemUnderlying(amount.rawAmount());
+  }
+  public async repay(amount: TokenAmount): Promise<TransactionResponse> {
+    if (isSameAddress(amount.token.address, ETHAddress)) {
+      return (this.auToken as AuETH).connect(this._networkConnection.signer!).repayBorrow({value: amount.rawAmount()});
+    } else {
+      return (this.auToken as AuErc20).connect(this._networkConnection.signer!).repayBorrow(amount.rawAmount());
+    }
   }
   public async enableCollateral(): Promise<TransactionResponse> {
-    return this.dummyTransaction();
+    return this._comptroller.connect(this._networkConnection.signer!).enterMarkets([this.auToken.address]);
   }
   public async disableCollateral(): Promise<TransactionResponse> {
-    return this.dummyTransaction();
+    return this._comptroller.connect(this._networkConnection.signer!).exitMarket(this.auToken.address);
   }
 }
 
 export class MoneyMarket extends BlockchainEntity {
   protected address: Address;
-  constructor(address: string) {
+
+  protected underlying: Address;
+  constructor(address: string, underlying: string) {
     super();
     this.address = validateAndParseAddress(address);
+    this.underlying = validateAndParseAddress(underlying);
   }
-  public read(provider: ProviderOrSigner): MoneyMarketRead {
-    return new MoneyMarketRead(provider, this.address);
+  public read(networkConnection: NetworkConnection): MoneyMarketRead {
+    return new MoneyMarketRead(networkConnection, this.address, this.underlying);
   }
 }

package/src/SDK.ts

@@ -1,109 +1,200 @@
 import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
-import {
-  dummyPly,
-  dummyPlyAurora,
-  dummyToken,
-  dummyTokenAmount2,
-  dummyTokenAmount3,
-  dummyUserMarketDetails,
-} from './dummy';
 import {
   LockingDetails,
   PlyAuroraPoolDetails,
-  ProviderOrSigner,
+  NetworkConnection,
   UserDetails,
+  UserMarketDetails,
+  Address,
+  CurrencyAmount,
 } from './types';
-import { Token, CurrencyAmount } from '@pendle/sdk-core';
-import { AVAX_DEFAULT_PROVIDER_URL, DOLLAR } from './constants';
+import { AVAX_DEFAULT_PROVIDER_URL, networkAddresses, BORROW_LIMIT_BUFFER, DECIMAL_PRECISION, REWARDCLAIMSTART, ONE_DAY, AurPlyPid } from './constants';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { Contract, BigNumber as BN, ethers, providers } from 'ethers';
+import { isSameAddress, decimalFactor, getCurrentTimestamp, calcLMRewardApr } from './helpers';
+import { MoneyMarketRead } from './MoneyMarket';
+import { fetchValuation, fetchPrice } from './priceFetcher';
+import { AuriFairLaunch, Comptroller, TokenLock } from '@aurigami/contracts/typechain';
+import { TokenAmount } from './tokenAmount';
+import { AURPLYToken, PLYToken, Token } from './token';
+import BigNumber from 'bignumber.js';
 import IERC20 from '@aurigami/contracts/artifacts/contracts/EIP20Interface.sol/EIP20Interface.json';
-import { Contract } from 'ethers';
-const ethers = require('ethers');
+import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
+import TokenLockABI from "@aurigami/contracts/artifacts/contracts/TokenLock.sol/TokenLock.json";
+import AuriFairLaunchABI from "@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json";
+import dummyABI from "./abis/dummy.json";
 
 export class SdkRead extends BlockchainEntityRead {
-  constructor(providerOrSigner: ProviderOrSigner) {
-    super(providerOrSigner);
+
+  protected _comptroller: Comptroller;
+  protected _tokenLock: TokenLock;
+  protected _auriFairLaunch: AuriFairLaunch;
+  protected _auriLens: Contract; // To-do
+  constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this._comptroller = new Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider) as Comptroller;
+    this._tokenLock = new Contract(networkAddresses.misc.TOKENLOCK, TokenLockABI.abi, networkConnection.provider) as TokenLock;
+    this._auriFairLaunch = new Contract(networkAddresses.misc.AURIFAIRLAUNCH, AuriFairLaunchABI.abi, networkConnection.provider) as AuriFairLaunch;
+    this._auriLens = new Contract(networkAddresses.misc.AURILENS, dummyABI.abi, networkConnection.provider); //To-do
   }
 
   public async getLockingDetails(): Promise<LockingDetails> {
+    const currentTime = await getCurrentTimestamp(this._networkConnection.provider);
+    const currentWeek = BN.from(currentTime - REWARDCLAIMSTART).div(7 * ONE_DAY).toNumber();
+    const denominator = 10000;
+    var promises = [];
+    promises.push(this._tokenLock.percentageLock(currentWeek));
+    promises.push(this._tokenLock.percentageLock(currentWeek + 1).catch((err: any) => {return denominator}));
+    var values: string[] = await Promise.all(promises).then((res) => {
+      return res.map((v) => {return v.toString()})
+    });
     return {
-      vestingStart: 1673280000, // 10 Jan 2023
-      currentUnlockPortion: 0.17,
-      nextUnlockPortion: 0.19,
+      vestingStart: REWARDCLAIMSTART, // 10 Jan 2023
+      currentUnlockPortion: new BigNumber(values[0]).div(denominator).toNumber(),
+      nextUnlockPortion: new BigNumber(values[1]).div(denominator).toNumber(),
     };
   }
 
   public async getUserDetails(userAddress: string): Promise<UserDetails> {
+    const marketCount = networkAddresses.auTokens.length;
+    var userMarketDetails: UserMarketDetails[] = [], assetsIn: string[];
+    var collateralRatio: BigNumber[];
+    var promises = [];
+    var totalBorrowLimit = new BigNumber(0);
+    var pricePromises = [];
+    for (const auToken of networkAddresses.auTokens) {
+      const userMarketDetail: UserMarketDetails = {} as UserMarketDetails;
+      userMarketDetails.push(userMarketDetail);
+      userMarketDetail.market = auToken.underlying;
+      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(this._networkConnection, auToken.address, auToken.underlying);
+      promises.push(moneyMarket.getUserDepositBalance(userAddress).then((res: TokenAmount) => {userMarketDetail.depositBalance = res}));
+      promises.push(moneyMarket.getUserBorrowBalance(userAddress).then((res: TokenAmount) => {userMarketDetail.borrowBalance = res}));
+      promises.push(moneyMarket.getCollateralRatio().then((res: BigNumber) => {collateralRatio[i] = res}));
+      pricePromises.push(fetchPrice(moneyMarket.underlying.address, this._networkConnection.provider));
+    }
+
+    promises.push(this._comptroller.getAssetsIn(userAddress).then((res: string[]) => {assetsIn = res}));
+    
+    await Promise.all(promises);
+    var underlyingPrices = await Promise.all(pricePromises);
+    var depositValuationPromises = [];
+
+    for (var i = 0; i < marketCount; i ++) {
+      const auToken = networkAddresses.auTokens[i];
+      if (assetsIn!.filter((auAddress: Address) => {
+        isSameAddress(auToken.address, auAddress)
+      }).length > 0) {
+        userMarketDetails[i].isCollateral = true;
+      }
+      depositValuationPromises.push(fetchValuation(userMarketDetails[i].depositBalance, this._networkConnection.provider, underlyingPrices[i]));
+    }
+
+    var depositValues = await Promise.all(depositValuationPromises);
+    totalBorrowLimit = depositValues.reduce((p: BigNumber, v: BigNumber, index: number)=> {
+      if (userMarketDetails[index].isCollateral) return p.plus(v.multipliedBy(collateralRatio[index]));
+      return p;
+    })
+
+    promises = [];
+    var accountLiquidity: [BN, BN, BN], rewardBalancesMetadata, lockedAmount: BN;
+    promises.push(this._comptroller.getAccountLiquidity(userAddress));
+    promises.push(this._auriLens.getRewardBalancesMetadata(this._comptroller.address, userAddress));
+    promises.push(this._tokenLock.lockedAmounts(userAddress));
+    var values = await Promise.all(promises);
+    accountLiquidity = values[0]; rewardBalancesMetadata = values[1]; lockedAmount = values[2];
+    const borrowedvaluation: BigNumber = totalBorrowLimit.minus(new BigNumber(accountLiquidity[1].toString()).div(decimalFactor(18)));
+    const bufferedBorrowLimit: BigNumber = totalBorrowLimit.multipliedBy(BORROW_LIMIT_BUFFER);
+
+    var borrowableAmount: BigNumber;
+    if (bufferedBorrowLimit.lte(borrowedvaluation)) {
+      borrowableAmount = new BigNumber(0)
+    } else {
+      borrowableAmount = bufferedBorrowLimit.minus(borrowedvaluation);
+    }
+
+    for (var i = 0; i < marketCount; i ++) {
+      const auToken = networkAddresses.auTokens[i];
+      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(this._networkConnection, auToken.address, auToken.underlying);
+      userMarketDetails[i].maxWithdrawableAmount = new TokenAmount(
+        moneyMarket.underlying,
+        borrowableAmount.div(underlyingPrices[i]).toFixed(18)
+      )
+    }
+
     return {
-      markets: [dummyUserMarketDetails],
-      borrowLimit: dummyTokenAmount3,
-      accruedPly: new CurrencyAmount({
-        currency: dummyPly,
-        amount: '100.12',
-        isRaw: false,
-      }),
-      lockedPly: new CurrencyAmount({
-        currency: dummyPly,
-        amount: '200.12',
-        isRaw: false,
-      }),
-      borrowableAmount: dummyTokenAmount2,
+      markets: userMarketDetails,
+      borrowLimit: {
+        currency: "USD",
+        amount: bufferedBorrowLimit.toFixed(DECIMAL_PRECISION)
+      },
+      accruedPly: new TokenAmount(PLYToken, rewardBalancesMetadata.plyAccrued.toString()),
+      lockedPly: new TokenAmount(PLYToken, lockedAmount.toString()),
+      borrowableAmount: {
+        currency: "USD",
+        amount: borrowableAmount.toFixed(DECIMAL_PRECISION)
+      },
     };
   }
 
   public async getPlyAuroraPoolDetails(): Promise<PlyAuroraPoolDetails> {
+    var stakedLiquidity: BN, rewardPerSecond: BN; 
+    var promises = [];
+    promises.push(this._auriFairLaunch.getPoolInfo(AurPlyPid).then((res) => {
+      stakedLiquidity =  res.totalStake;
+      rewardPerSecond = res.rewardPerSecond;  
+    }));
+    await Promise.all(promises);
+
+    promises = [];
+    var rewardPerSecondValuation: BigNumber, totalStakeValuation: BigNumber;
+    promises.push(fetchValuation(new TokenAmount(
+      PLYToken,
+      rewardPerSecond!.toString()
+    ), this._networkConnection.provider).then((res) => rewardPerSecondValuation = res));
+    promises.push(fetchValuation(new TokenAmount(
+      AURPLYToken,
+      stakedLiquidity!.toString()
+    ), this._networkConnection.provider).then((res) => totalStakeValuation = res));
+
     return {
-      totalStakedLiquidity: new CurrencyAmount({
-        currency: dummyPlyAurora,
-        amount: '12.1',
-        isRaw: false,
-      }),
-      apy: 1.21,
+      totalStakedLiquidity: new TokenAmount(
+        AURPLYToken,
+        stakedLiquidity!.toString()
+      ),
+      apy: calcLMRewardApr(rewardPerSecondValuation!, totalStakeValuation!, ONE_DAY * 365).toFixed(DECIMAL_PRECISION),
     };
   }
 
   public async getTokenPrice(token: Token): Promise<CurrencyAmount> {
-    if (token.address == dummyToken.address) {
-      return new CurrencyAmount({
-        currency: DOLLAR,
-        amount: '1',
-        isRaw: false,
-      });
+    const price = await fetchPrice(token.address, this._networkConnection.provider);
+    return {
+      currency: "USD",
+      amount: price.toFixed(DECIMAL_PRECISION)
     }
-
-    return new CurrencyAmount({
-      currency: DOLLAR,
-      amount: '12.1',
-      isRaw: false,
-    });
   }
-  public async stakeBalanceOf(user: string): Promise<CurrencyAmount> {
-    return new CurrencyAmount({
-      currency: dummyPlyAurora,
-      amount: '103.4',
-      isRaw: false,
-    });
+  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
+    const userInfo = await this._auriFairLaunch.getUserInfo(AurPlyPid, user);
+    return new TokenAmount(
+      AURPLYToken,
+      userInfo.amount.toString()
+    )
   }
 }
 
 export class SdkReadWrite extends SdkRead {
-  dummyTransaction = async (): Promise<TransactionResponse> => {
-    // const dummyErc20Token = new Contract(
-    //   dummyToken.address,
-    //   IERC20.abi,
-    //   this._providerOrSigner
-    // );
-    // return await dummyErc20Token.approve(dummyToken.address, 123);
-    return {} as TransactionResponse;
-  };
   public async claim(): Promise<TransactionResponse> {
-    return this.dummyTransaction();
+    return this._auriLens.connect(this._networkConnection.signer!).claimRewards(
+      this._comptroller.address,
+      this._auriFairLaunch.address,
+      await this._networkConnection.signer!.getAddress(),
+      [AurPlyPid]
+    );
   }
-  public async stake(amount: CurrencyAmount): Promise<TransactionResponse> {
-    return this.dummyTransaction();
+  public async stake(amount: TokenAmount): Promise<TransactionResponse> {
+    return this._auriFairLaunch.connect(this._networkConnection.signer!).deposit(AurPlyPid, amount.rawAmount(), false);
   }
-  public async unstake(amount: CurrencyAmount): Promise<TransactionResponse> {
-    return this.dummyTransaction();
+  public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
+    return this._auriFairLaunch.connect(this._networkConnection.signer!).withdraw(AurPlyPid, amount.rawAmount());
   }
 }
 
@@ -111,11 +202,11 @@ export class SDK extends BlockchainEntity {
   constructor() {
     super();
   }
-  public read(provider: ProviderOrSigner): SdkRead {
-    return new SdkRead(provider);
+  public read(networkConnection: NetworkConnection): SdkRead {
+    return new SdkRead(networkConnection);
   }
 
-  public static defaultProvider(): ProviderOrSigner {
+  public static defaultProvider(): providers.Provider {
     return new ethers.providers.JsonRpcProvider(AVAX_DEFAULT_PROVIDER_URL);
   }
 }