@aurigami/sdk 1.6.4 → 1.6.6

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.6.4",
+  "version": "1.6.6",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -8,7 +8,7 @@
     "src"
   ],
   "engines": {
-    "node": ">=10"
+    "node": ">=14"
   },
   "scripts": {
     "start": "tsdx watch",
@@ -33,20 +33,22 @@
   "size-limit": [
     {
       "path": "dist/sdk.cjs.production.min.js",
-      "limit": "10 KB"
+      "limit": "300 KB"
     },
     {
       "path": "dist/sdk.esm.js",
-      "limit": "10 KB"
+      "limit": "300 KB"
     }
   ],
   "devDependencies": {
     "@nomiclabs/hardhat-ethers": "^2.0.5",
     "@nomiclabs/hardhat-etherscan": "^3.0.3",
     "@nomiclabs/hardhat-waffle": "^2.0.3",
-    "@size-limit/preset-small-lib": "^7.0.8",
+    "@size-limit/preset-big-lib": "^7.0.8",
+    "@size-limit/webpack-why": "^7.0.8",
     "@types/mocha": "^9.1.0",
     "chai": "^4.3.6",
+    "dotenv": "^16.0.1",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
     "ethereum-waffle": "^3.4.4",
@@ -63,7 +65,6 @@
     "@aurigami/contracts": "3.6.0",
     "axios": "^0.26.1",
     "bignumber.js": "^9.0.2",
-    "dotenv": "^16.0.0",
     "ethers": "^5.6.4"
   }
 }

package/src/SDK.ts

@@ -1,213 +1,22 @@
-import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import FaucetABI from '@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json';
-import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
-import {
-  AuriFairLaunch,
-  AuriLens,
-  Comptroller,
-  IERC20,
-} from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract } from 'ethers';
 import * as consts from './consts';
-import {
-  MoneyMarketRead,
-  PapermillRead,
-  StakingRead,
-  StakingReadWrite,
-} from './contracts';
-import {
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYToken,
-  Token,
-  TokenAmount,
-} from './entities';
-import { decimalFactor, isSameAddress } from './helpers/helpers';
-import { calcValuation, fetchPrice } from './helpers/priceFetcher';
+import { MiscRead, StakingRead, StakingReadWrite } from './contracts';
+import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from './entities';
 import * as types from './types';
-import { MulticallRead } from './contracts/Multicall';
 
 export class SdkRead extends BlockchainEntityRead {
-  protected _comptroller: Comptroller;
-  protected _auriFairLaunch: AuriFairLaunch;
-  protected _auriLens: AuriLens;
+  protected env: AuriEnv;
   protected _stakingRead: StakingRead;
+  protected _misc: MiscRead;
   constructor(networkConnection: types.NetworkConnection) {
     super(networkConnection);
+    this.env = new AuriEnv(networkConnection);
     this._stakingRead = new StakingRead(networkConnection);
-    this._comptroller = new Contract(
-      consts.networkAddresses.misc.COMPTROLLER,
-      ComptrollerABI.abi,
-      networkConnection.provider
-    ) as Comptroller;
-    this._auriFairLaunch = new Contract(
-      consts.networkAddresses.misc.AURIFAIRLAUNCH,
-      AuriFairLaunchABI.abi,
-      networkConnection.provider
-    ) as AuriFairLaunch;
-    this._auriLens = new Contract(
-      consts.networkAddresses.misc.AURILENS,
-      AuriLensABI.abi,
-      networkConnection.provider
-    ) as AuriLens;
+    this._misc = new MiscRead(networkConnection);
   }
 
   public async getUserDetails(userAddress: string): Promise<types.UserDetails> {
-    const marketCount = consts.networkAddresses.auTokens.length;
-    var userMarketDetails: types.UserMarketDetails[] = [],
-      assetsIn: string[];
-    var promises = [];
-    var totalBorrowLimit = new BigNumber(0);
-    var pricePromises = [];
-    for (const auToken of consts.networkAddresses.auTokens) {
-      const userMarketDetail: types.UserMarketDetails =
-        {} as types.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) => {
-          userMarketDetail.collateralRatio = res.toNumber();
-        })
-      );
-      pricePromises.push(
-        fetchPrice(
-          moneyMarket.underlying.address,
-          this._networkConnection.provider
-        ).then((res) => {
-          userMarketDetail.underlyingPrice = res.toString();
-          return res;
-        })
-      );
-    }
-
-    promises.push(
-      this._comptroller.getAssetsIn(userAddress).then((res: string[]) => {
-        assetsIn = res;
-      })
-    );
-
-    await Promise.all(promises);
-    var underlyingPrices = await Promise.all(pricePromises);
-    var depositValues = [];
-    for (var i = 0; i < marketCount; i++) {
-      const auToken = consts.networkAddresses.auTokens[i];
-      if (
-        assetsIn!.find((auAddress: types.Address) =>
-          isSameAddress(auToken.address, auAddress)
-        ) !== undefined
-      ) {
-        userMarketDetails[i].isCollateral = true;
-      } else {
-        userMarketDetails[i].isCollateral = false;
-      }
-      depositValues.push(
-        calcValuation(userMarketDetails[i].depositBalance, underlyingPrices[i])
-      );
-    }
-
-    totalBorrowLimit = depositValues.reduce(
-      (p: BigNumber, v: BigNumber, index: number) => {
-        if (userMarketDetails[index].isCollateral)
-          return p.plus(
-            v.multipliedBy(userMarketDetails[index].collateralRatio)
-          );
-        return p;
-      },
-      new BigNumber(0)
-    );
-
-    var accountLiquidity: [BN, BN] =
-      await this._comptroller.getAccountLiquidity(userAddress);
-
-    var borrowedvaluation: BigNumber = totalBorrowLimit.minus(
-      new BigNumber(accountLiquidity[0].toString()).div(decimalFactor(18))
-    );
-
-    if (borrowedvaluation.lt('0.00001')) {
-      // Igore dust, dust could be the result of network delay causing collateral valuation calc to be different on vs off chain
-      borrowedvaluation = new BigNumber(0);
-    }
-
-    const bufferedBorrowLimit: BigNumber = totalBorrowLimit.multipliedBy(
-      consts.BORROW_LIMIT_BUFFER
-    );
-    const minimumBorrowLimitAllowed = borrowedvaluation.div(
-      consts.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 = consts.networkAddresses.auTokens[i];
-      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-        this._networkConnection,
-        auToken.address,
-        auToken.underlying
-      );
-      const borrowLimitMargin = totalBorrowLimit
-        .minus(minimumBorrowLimitAllowed)
-        .gt(0)
-        ? totalBorrowLimit.minus(minimumBorrowLimitAllowed)
-        : new BigNumber(0);
-      const maxWithdrawCap: BigNumber = borrowLimitMargin
-        .div(userMarketDetails[i].collateralRatio)
-        .div(underlyingPrices[i]);
-      userMarketDetails[i].maxWithdrawableAmount =
-        userMarketDetails[i].isCollateral &&
-        maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
-          ? new TokenAmount(
-              moneyMarket.underlying,
-              maxWithdrawCap.toFixed(24),
-              false
-            )
-          : new TokenAmount(
-              moneyMarket.underlying,
-              userMarketDetails[i].depositBalance.rawAmount()
-            );
-    }
-
-    return {
-      markets: userMarketDetails,
-      borrowLimit: {
-        currency: 'USD',
-        amount: bufferedBorrowLimit.toFixed(consts.DECIMAL_PRECISION),
-      },
-      userLockingDetails: await new PapermillRead(
-        this._networkConnection
-      ).getLockingDetails(userAddress),
-      borrowableAmount: {
-        currency: 'USD',
-        amount: borrowableAmount.toFixed(consts.DECIMAL_PRECISION),
-      },
-    };
+    return this._misc.getUserDetails(userAddress);
   }
 
   public async getPLYWNEARPoolDetails(): Promise<types.PLYWNEARPoolDetails> {
@@ -215,14 +24,7 @@ export class SdkRead extends BlockchainEntityRead {
   }
 
   public async getTokenPrice(token: Token): Promise<types.CurrencyAmount> {
-    const price = await fetchPrice(
-      token.address,
-      this._networkConnection.provider
-    );
-    return {
-      currency: 'USD',
-      amount: price.toFixed(consts.DECIMAL_PRECISION),
-    };
+    return this._misc.getTokenPrice(token);
   }
 
   /**
@@ -256,60 +58,13 @@ export class SdkRead extends BlockchainEntityRead {
     action: types.MarketAction;
     tokenAmount?: TokenAmount;
   }): types.HypotheticalStats {
-    var newBorrowLimit = new BigNumber(currentBorrowLimit.amount),
-      newBorrowValuation = new BigNumber(currentBorrowValuation.amount);
-    switch (action) {
-      case types.MarketAction.EnableCollateral:
-      case types.MarketAction.DisableCollateral:
-        var deltaBorrowLimit = calcValuation(
-          userMarketDetail.depositBalance,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        )
-          .multipliedBy(userMarketDetail.collateralRatio)
-          .multipliedBy(consts.BORROW_LIMIT_BUFFER);
-        newBorrowLimit =
-          action == types.MarketAction.EnableCollateral
-            ? newBorrowLimit.plus(deltaBorrowLimit)
-            : newBorrowLimit.minus(deltaBorrowLimit);
-        break;
-
-      case types.MarketAction.Deposit:
-      case types.MarketAction.Withdraw:
-        deltaBorrowLimit = calcValuation(
-          tokenAmount!,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        )
-          .multipliedBy(userMarketDetail.collateralRatio)
-          .multipliedBy(consts.BORROW_LIMIT_BUFFER);
-        newBorrowLimit =
-          action == types.MarketAction.Deposit
-            ? newBorrowLimit.plus(deltaBorrowLimit)
-            : newBorrowLimit.minus(deltaBorrowLimit);
-        break;
-
-      case types.MarketAction.Borrow:
-      case types.MarketAction.Repay:
-        var deltaBorrowValuation = calcValuation(
-          tokenAmount!,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        );
-        newBorrowValuation =
-          action == types.MarketAction.Borrow
-            ? newBorrowValuation.plus(deltaBorrowValuation)
-            : newBorrowValuation.minus(deltaBorrowValuation);
-        break;
-    }
-    return {
-      newBorrowLimit: {
-        amount: newBorrowLimit!.toFixed(consts.DECIMAL_PRECISION),
-        currency: 'USD',
-      },
-      newBorrowUtilization: newBorrowLimit.eq(0)
-        ? newBorrowValuation.eq(0)
-          ? 0
-          : 9999.99
-        : newBorrowValuation!.div(newBorrowLimit!).toNumber(),
-    };
+    return this._misc.calcHypotheticalStats({
+      userMarketDetail,
+      currentBorrowLimit,
+      currentBorrowValuation,
+      action,
+      tokenAmount,
+    });
   }
 
   /**
@@ -321,57 +76,7 @@ export class SdkRead extends BlockchainEntityRead {
    *  - Ply in vesting contract
    */
   public async getPlyCirculatingSupply(): Promise<TokenAmount> {
-    const plyContract: IERC20 = new Contract(
-      consts.networkAddresses.tokens.PLY,
-      EIP20InterfaceABI.abi,
-      this._networkConnection.provider
-    ) as IERC20;
-
-    const multicallRead = new MulticallRead(this._networkConnection);
-    const baseBalanceOfCall = {
-      contract: plyContract,
-      method: 'balanceOf',
-      returnTypes: ['uint256'],
-    };
-
-    const callResults = (await multicallRead.aggregate([
-      // Get total supply
-      {
-        ...baseBalanceOfCall,
-        method: 'totalSupply',
-        args: [],
-      },
-      // balance in team multisig
-      {
-        ...baseBalanceOfCall,
-        args: [consts.networkAddresses.misc.TEAM_MULTISIG],
-      },
-      // balance in comptroller
-      {
-        ...baseBalanceOfCall,
-        args: [consts.networkAddresses.misc.COMPTROLLER],
-      },
-      // balance in fair launch
-      {
-        ...baseBalanceOfCall,
-        args: [consts.networkAddresses.misc.AURIFAIRLAUNCH],
-      },
-      // balance in vesting contract
-      {
-        ...baseBalanceOfCall,
-        args: [consts.networkAddresses.misc.PLY_TOKEN_LOCK],
-      },
-    ])) as BN[][];
-    let circulatingSupply: BN = BN.from(0);
-    callResults.forEach((result, i) => {
-      if (i === 0) {
-        circulatingSupply = result[0];
-      } else {
-        circulatingSupply = circulatingSupply.sub(result[0]);
-      }
-    });
-
-    return new TokenAmount(PLYToken, circulatingSupply.toString());
+    return this._misc.getPlyCirculatingSupply();
   }
 }
 
@@ -380,22 +85,15 @@ export class SdkReadWrite extends SdkRead {
    * Claim PLY reward in all markets + staking pools
    */
   public async claim(): Promise<TransactionResponse> {
-    return this._comptroller
+    return this.env.comptroller
       .connect(this._networkConnection.signer!)
-      ['claimReward(uint8,address)'](
-        0,
-        await this._networkConnection.signer!.getAddress()
-      );
+      ['claimReward(uint8,address)'](0, await this._networkConnection.signer!.getAddress());
   }
 
   public async claimLpRewards(): Promise<TransactionResponse> {
-    return this._auriFairLaunch
+    return this.env.auriFairLaunch
       .connect(this._networkConnection.signer!)
-      .harvest(
-        await this._networkConnection.signer!.getAddress(),
-        0,
-        consts.INF
-      );
+      .harvest(await this._networkConnection.signer!.getAddress(), 0, consts.INF);
   }
 
   public async stake(amount: TokenAmount): Promise<TransactionResponse> {
@@ -406,14 +104,9 @@ export class SdkReadWrite extends SdkRead {
     return new StakingReadWrite(this._networkConnection).unstake(amount);
   }
 
-  public async faucetDrip(): Promise<TransactionResponse> {
-    const faucet = new Contract(
-      consts.networkAddresses.misc.FAUCET,
-      FaucetABI.abi,
-      this._networkConnection.provider
-    );
-    return faucet.connect(this._networkConnection.signer!).drip();
-  }
+  // public async faucetDrip(): Promise<TransactionResponse> {
+  //   return this.env.faucet.connect(this._networkConnection.signer!).drip();
+  // }
 }
 
 export class SDK extends BlockchainEntity {

package/src/abis/index.ts

@@ -0,0 +1,30 @@
+import AuErc20ABI from '@aurigami/contracts/artifacts/contracts/AuErc20.sol/AuErc20.json';
+import AuETHABI from '@aurigami/contracts/artifacts/contracts/AuETH.sol/AuETH.json';
+import AuriAirdropABI from '@aurigami/contracts/artifacts/contracts/AuriAirdrop.sol/AuriAirdrop.json';
+import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
+import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
+import AuriOracleABI from '@aurigami/contracts/artifacts/contracts/AuriOracle.sol/AuriOracle.json';
+import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
+import EthRepayHelperABI from '@aurigami/contracts/artifacts/contracts/EthRepayHelper.sol/EthRepayHelper.json';
+import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
+// import FaucetABI from '@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json';
+import IUniswapV2PairABI from '@aurigami/contracts/artifacts/contracts/mock/IUniswapV2Pair.sol/IUniswapV2Pair.json';
+import Multicall2ABI from '@aurigami/contracts/artifacts/contracts/mock/Multicall2.sol/Multicall2.json';
+import PulpABI from '@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json';
+import ReferralDirectoryABI from '@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json';
+export {
+  AuriOracleABI,
+  IUniswapV2PairABI,
+  AuriAirdropABI,
+  AuriFairLaunchABI,
+  AuriLensABI,
+  ComptrollerABI,
+  // FaucetABI,
+  EIP20InterfaceABI,
+  ReferralDirectoryABI,
+  AuErc20ABI,
+  AuETHABI,
+  EthRepayHelperABI,
+  Multicall2ABI,
+  PulpABI,
+};

package/src/consts/constants.ts

@@ -1,8 +1,7 @@
 import BigNumber from 'bignumber.js';
-import { ethers, Signer, BigNumber as BN } from 'ethers';
+import { BigNumber as BN } from 'ethers';
 import { MAINNET_ADDRESSES } from './deployments';
-export const dummyAddress: string =
-  '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE';
+export const dummyAddress: string = '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE';
 export const ETHAddress: string = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
 
 export const AURORA_CHAINID = 1313161554;
@@ -136,21 +135,21 @@ export const AIRDROP_START_TIMESTAMP = 1649858400;
 export const AIRDROP_END_TIMESTAMP = 1651068000;
 export const AIRDROP_KEEP_THRESHOLD = 7 * 86400;
 
-export const DEPOSIT_NEAR_REWARDS_PER_WEEK: { [k: string]: string } =
-  Object.fromEntries(
-    // lower case all addresses
-    Object.entries({
-      '0xb12bfca5a55806aaf64e99521918a4bf0fc40802': '36375', // USDC
-      '0x4988a896b1227218e4a686fde5eabdcabd91571f': '14550', // USDT
-      '0xf4eb217ba2454613b15dbdea6e5f22276410e89e': '3638', // WBTC
-      '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE': '14550', // ETH
-      '0xc42c30ac6cc15fac9bd938618bcaa1a1fae8501d': '3638', // WNEAR
-    }).map(([k, v]) => [k.toLowerCase(), v])
-  );
+export const DEPOSIT_NEAR_REWARDS_PER_WEEK: { [k: string]: string } = Object.fromEntries(
+  // lower case all addresses
+  Object.entries({
+    '0xb12bfca5a55806aaf64e99521918a4bf0fc40802': '36375', // USDC
+    '0x4988a896b1227218e4a686fde5eabdcabd91571f': '14550', // USDT
+    '0xf4eb217ba2454613b15dbdea6e5f22276410e89e': '3638', // WBTC
+    '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE': '14550', // ETH
+    '0xc42c30ac6cc15fac9bd938618bcaa1a1fae8501d': '3638', // WNEAR
+  }).map(([k, v]) => [k.toLowerCase(), v])
+);
 
 export const BORROW_NEAR_REWARDS_PER_WEEK: { [k: string]: string } = {
   // currently 0 for all markets
 };
 
-export const HARDCODE_PRICE_TOKENS: { [k: string]: string } =
-  Object.fromEntries([[networkAddresses.tokens.USN.toLowerCase(), '1']]);
+export const HARDCODE_PRICE_TOKENS: { [k: string]: string } = Object.fromEntries([
+  [networkAddresses.tokens.USN.toLowerCase(), '1'],
+]);

package/src/consts/dummy.ts

@@ -1,21 +1,11 @@
-import { Token } from '../entities';
-import { TokenAmount } from '../entities';
+import { Token, TokenAmount } from '../entities';
 import { UserMarketDetails } from '../types';
 
-export const dummyToken = new Token(
-  '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
-  6
-);
+export const dummyToken = new Token('0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e', 6);
 
-export const dummyPly = new Token(
-  '0x8729438eb15e2c8b576fcc6aecda6a148776c0f5',
-  18
-);
+export const dummyPly = new Token('0x8729438eb15e2c8b576fcc6aecda6a148776c0f5', 18);
 
-export const dummyPlyAurora = new Token(
-  '0xE530dC2095Ef5653205CF5ea79F8979a7028065c',
-  18
-);
+export const dummyPlyAurora = new Token('0xE530dC2095Ef5653205CF5ea79F8979a7028065c', 18);
 
 export const dummyTokenAmount = new TokenAmount(dummyToken, '123.456', false);
 

package/src/contracts/Airdrop.ts

@@ -0,0 +1,80 @@
+import { AuriAirdrop } from '@aurigami/contracts/typechain';
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { BigNumber as BN, Contract, utils } from 'ethers';
+import { AuriAirdropABI } from '../abis';
+import * as consts from '../consts';
+import { BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from '../entities';
+import * as helpers from '../helpers';
+import { Address, NetworkConnection } from '../types';
+
+export class AirdropRead extends BlockchainEntityRead {
+  public readonly airDrop: AuriAirdrop;
+
+  public constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+
+    this.airDrop = new Contract(
+      consts.networkAddresses.misc.AURI_AIRDROP,
+      AuriAirdropABI.abi,
+      networkConnection.provider
+    ) as AuriAirdrop;
+  }
+
+  /**
+   * Get redeemable rewards amount of user
+   */
+  public async getRedeemableReward(
+    campaign: string,
+    token: Address,
+    user: Address
+  ): Promise<TokenAmount> {
+    let tokenInstance: Token = new Token(token, helpers.getDecimal(token));
+
+    let rewards: BN = await this.airDrop.getRedeemableReward(
+      utils.formatBytes32String(campaign),
+      token,
+      user
+    );
+
+    return new TokenAmount(tokenInstance, rewards.toString());
+  }
+}
+
+export class AirdropReadWrite extends AirdropRead {
+  /**
+   * Transfer rewards from multiple campaigns to msg.sender
+   */
+  public async redeemMultiple(
+    campaigns: string[],
+    tokens: Address[]
+  ): Promise<TransactionResponse> {
+    helpers.assert(
+      campaigns.length == tokens.length,
+      'campaigns and tokens must have the same length'
+    );
+    return this.airDrop.connect(this._networkConnection.signer!).redeem(
+      campaigns.map((e) => utils.formatBytes32String(e)),
+      tokens,
+      await this._networkConnection.signer!.getAddress()
+    );
+  }
+
+  /**
+   * Redeem reward from a single campaign
+   */
+  public async redeemSingle(campaign: string, token: Address): Promise<TransactionResponse> {
+    return this.redeemMultiple([campaign], [token]);
+  }
+}
+
+export class Airdrop extends BlockchainEntity {
+  constructor() {
+    super();
+  }
+  public read(networkConnection: NetworkConnection): AirdropRead {
+    return new AirdropRead(networkConnection);
+  }
+  public readWrite(networkConnection: NetworkConnection): AirdropReadWrite {
+    return new AirdropReadWrite(networkConnection);
+  }
+}