@aurigami/sdk 1.23.0 → 1.24.0

package/src/helpers/multicall.ts

@@ -0,0 +1,251 @@
+import type { BlockTag } from '@ethersproject/abstract-provider';
+import type { Provider } from '@ethersproject/providers';
+
+import { CallOverrides, Contract, ContractInterface, Signer } from 'ethers';
+import { FunctionFragment, Interface } from 'ethers/lib/utils';
+import { Multicall2ABI } from '../abis';
+import { MulticallOverrides, MulticallStatic } from '../types';
+
+// export const MULTICALL_ADDRESSES: Record<ChainId, Address> = {
+//     [CHAIN_ID_MAPPING.ETHEREUM]: toAddress('0x5ba1e12693dc8f9c48aad8770482f4739beed696'),
+//     [CHAIN_ID_MAPPING.FUJI]: toAddress('0x07e46d95cc98f0d7493d679e89e396ea99020185'),
+//     [CHAIN_ID_MAPPING.MUMBAI]: toAddress('0x7De28d05a0781122565F3b49aA60331ced983a19'),
+//     [CHAIN_ID_MAPPING.ARBITRUM]: toAddress('0xcA11bde05977b3631167028862bE2a173976CA11'),
+// } as const;
+
+/**
+ * Multicall implementation, allowing to call function of contract.callStatic functions
+ * using multicall with Promise (without overrides).
+ *
+ * Example usage:
+ *     const multicall = new Multicall({
+ *          chainId,
+ *          provider,
+ *     });
+ *     const contract = new Contract(address, PendleERC20ABI, networkConnection.provider) as PendleERC20;
+ *
+ *     // very small interface changes
+ *     const balance = await multicall.wrap(contract).callStatic.balanceOf(userAddress);
+ *
+ *     // multiple calls
+ *     const users = [addr1, addr2, addr3];
+ *     const balances = await Promise.all(user.map((addr) => multicall.wrap(contract).callStatic.balanceOf(addr)));
+ *
+ * ### Result caching
+ * Multicall#wrap will cache the result right in the contract object. To access the cache result without
+ * calling the wrap function, use
+ *
+ *      contract[multicall.multicallStaticSymbol]
+ *
+ * Note that the field `multicallStaticSymbol` is **not** static, but local to the multicall instance.
+ */
+
+const TRANSFORMER = new Interface([]);
+export const DEFAULT_CALL_LIMIT = 32;
+
+class ContractCall {
+  fragment: FunctionFragment;
+  address: string;
+  params: any[];
+
+  constructor({
+    fragment,
+    address,
+    params,
+  }: {
+    fragment: FunctionFragment;
+    address: string;
+    params: any[];
+  }) {
+    this.fragment = fragment;
+    this.address = address;
+    this.params = params;
+  }
+}
+
+export class Multicall {
+  static isMulticallOverrides(
+    overrides?: CallOverrides
+  ): overrides is MulticallOverrides | undefined {
+    if (overrides === undefined) {
+      return true;
+    }
+    for (const key of Object.keys(overrides)) {
+      if (key !== 'blockTag' && (overrides as any)[key] != undefined) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private multicallContract: Contract;
+  public readonly batchMap = new Map<BlockTag, MulticallBatch>();
+  readonly callLimit: number;
+
+  // Note: this symbol is unique for each Multicall instance
+  readonly multicallStaticSymbol = Symbol.for('multicallStatic');
+
+  /**
+   * Perform _soft_ wrapping. If muticall is presented, multicall.wrap(contract) will be returned.
+   * Otherwise the contract itself will be returned. Note that this function is also type-safe,
+   * that is, even if the contract is returned, the user is disallowed to call functions
+   * with overrides.
+   *
+   * This function is useful in case where the user when to choose whether to use multicall
+   * by themselves.
+   */
+  static wrap<T extends Contract>(
+    contract: T,
+    multicall: Multicall | undefined
+  ): MulticallStatic<T> {
+    return multicall ? multicall.wrap(contract) : (contract as unknown as MulticallStatic<T>);
+  }
+
+  constructor({
+    address,
+    provider,
+    callLimit,
+  }: {
+    address: string;
+    provider: Provider | Signer;
+    callLimit?: number;
+  }) {
+    this.multicallContract = new Contract(address, Multicall2ABI.abi, provider);
+    this.callLimit = callLimit ?? DEFAULT_CALL_LIMIT;
+  }
+
+  async doAggregateCalls(calls: readonly ContractCall[], blockTag: BlockTag) {
+    const callRequests = calls.map((call) => ({
+      target: call.address,
+      callData: TRANSFORMER.encodeFunctionData(call.fragment, call.params),
+    }));
+
+    const responses = await this.multicallContract.callStatic.tryAggregate(false, callRequests, {
+      blockTag: blockTag,
+    });
+
+    const result = calls.map((call, i) => {
+      const [success, returnData] = responses[i];
+
+      try {
+        const outputs: any[] = call.fragment.outputs!;
+        const params = TRANSFORMER.decodeFunctionResult(call.fragment, returnData);
+
+        // If we do the !success check before the decode, we cannot get the error message of
+        // decodeFunctionResult. So we always decode first, then check the success later.
+        if (!success) {
+          const callId = FunctionFragment.from(call.fragment).format();
+          throw new Error(`Call ${call.address}:${callId} failed`);
+        }
+
+        return outputs.length === 1 ? params[0] : params;
+      } catch (e: any) {
+        if (e.reason == null) {
+          e.reason = 'Call failed for unknown reason';
+        }
+        return e;
+      }
+    });
+
+    return result;
+  }
+
+  wrap<T extends Contract>(contract_: T): MulticallStatic<T> {
+    const contract = contract_ as T & { [key in symbol]: MulticallStatic<T> };
+    if (contract[this.multicallStaticSymbol]) {
+      return contract[this.multicallStaticSymbol];
+    }
+    const functions = contract_.interface.functions;
+    const funcs: Record<string, (...args: any[]) => Promise<any>> = {};
+
+    for (const [_, fn] of Object.entries(functions)) {
+      funcs[fn.name] = async (...params: any[]) => {
+        let blockTag: BlockTag = 'latest';
+        if (params.length === fn.inputs.length + 1) {
+          const overrides: MulticallOverrides = params.pop() ?? {};
+          if (!Multicall.isMulticallOverrides(overrides)) {
+            throw new Error('Overrides for multicall should contain only blockTag property');
+          }
+          blockTag = (await overrides.blockTag) ?? 'latest';
+        }
+
+        const contractCall = new ContractCall({
+          fragment: fn,
+          address: contract.address,
+          params,
+        });
+        const res = new Promise((resolve, reject) => {
+          let currentBatch = this.batchMap.get(blockTag);
+          if (currentBatch === undefined) {
+            currentBatch = new MulticallBatch(this, blockTag);
+            this.batchMap.set(blockTag, currentBatch);
+          }
+          const dataPos = currentBatch.pendingContractCalls.length;
+          currentBatch.pendingContractCalls.push(contractCall);
+          currentBatch.promise
+            .then((currentResult) =>
+              currentResult[dataPos] instanceof Error
+                ? reject(currentResult[dataPos])
+                : resolve(currentResult[dataPos])
+            )
+            .catch(reject);
+          if (currentBatch.pendingContractCalls.length >= this.callLimit) {
+            this.batchMap.delete(blockTag);
+          }
+        });
+
+        return res;
+      };
+    }
+
+    const res = {
+      callStatic: funcs,
+      address: contract.address,
+      raw: contract,
+    } as unknown as MulticallStatic<T>;
+
+    // Do this to avoid typescript error.
+    Object.assign(contract, { [this.multicallStaticSymbol]: res });
+
+    return res;
+  }
+}
+
+class MulticallBatch {
+  readonly pendingContractCalls: ContractCall[] = [];
+  readonly promise: Promise<any[]>;
+
+  constructor(
+    private readonly multicallInstance: Multicall,
+    readonly blockTag: BlockTag = 'latest'
+  ) {
+    this.promise = Promise.resolve().then(async () => {
+      // effects
+
+      // instance comparison
+      if (this.multicallInstance.batchMap.get(this.blockTag) === this) {
+        this.multicallInstance.batchMap.delete(this.blockTag);
+      }
+
+      // interactions
+      return this.multicallInstance.doAggregateCalls(this.pendingContractCalls, this.blockTag);
+    });
+  }
+}
+
+let multicall: Multicall | undefined;
+
+export function createContract<T extends Contract>(
+  addressOrName: string,
+  contractInterface: ContractInterface,
+  signerOrProvider: Signer | Provider
+) {
+  const contract = new Contract(addressOrName, contractInterface, signerOrProvider) as T;
+  if (!multicall) {
+    multicall = new Multicall({
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      provider: signerOrProvider,
+    });
+  }
+  return Multicall.wrap(contract, multicall);
+}

package/src/helpers/priceFetcher.ts

@@ -2,7 +2,7 @@ import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/Au
 import { AuriPythOracle, ERC20, IUniswapV2Pair } from '@aurigami/contracts/typechain';
 import axios from 'axios';
 import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract, ethers, providers } from 'ethers';
+import { BigNumber as BN, ethers, providers } from 'ethers';
 import { AuriOracleABI, EIP20InterfaceABI, IUniswapV2PairABI } from '../abis';
 import {
   DECIMAL_PRECISION,
@@ -16,11 +16,12 @@ import { TokenAmount } from '../entities/tokenAmount';
 import { Address, TokenValuation } from '../types';
 import { assert, decimalFactor, devLog, getDecimal, isSameAddress } from './helpers';
 import { getSwapInfo } from './kyber-aggregator-api';
+import { createContract } from './multicall';
 import { getQuoteOneInch } from './one-inch-aggregator-api';
 
 export async function prepareParamsAggregator(address: string, provider: providers.Provider) {
-  const tokenInErc20 = new Contract(address, EIP20InterfaceABI.abi, provider) as ERC20;
-  const tokenInDecimal = await tokenInErc20.decimals();
+  const tokenInErc20 = createContract<ERC20>(address, EIP20InterfaceABI.abi, provider);
+  const tokenInDecimal = await tokenInErc20.callStatic.decimals();
   const tokenInQuantity = BN.from(10).pow(tokenInDecimal).toString();
   const usdtAddress =
     networkAddresses.auTokens.find((autoken) => autoken.name == 'auUSDT')?.underlying ?? '';
@@ -137,12 +138,12 @@ export async function fetchLPPositions(
   reserve1: BN;
   totalSupply: BN;
 }> {
-  const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider) as IUniswapV2Pair;
+  const LPContract = createContract<IUniswapV2Pair>(LPAddress, IUniswapV2PairABI.abi, provider);
   const [token0, token1, reserves, totalSupply] = await Promise.all([
-    LPContract.token0(),
-    LPContract.token1(),
-    LPContract.getReserves(),
-    LPContract.totalSupply(),
+    LPContract.callStatic.token0(),
+    LPContract.callStatic.token1(),
+    LPContract.callStatic.getReserves(),
+    LPContract.callStatic.totalSupply(),
   ]);
 
   return {
@@ -229,15 +230,17 @@ export async function fetchPriceFromOracle(
   underlyingDecimal: number,
   provider: providers.Provider
 ): Promise<BigNumber> {
-  const oracleContract: AuriPythOracle = new Contract(
+  const oracleContract = createContract<AuriPythOracle>(
     networkAddresses.misc.PYTH_ORACLE,
     AuriOracleABI.abi,
     provider
-  ) as AuriPythOracle;
-  const rawPrice = await oracleContract.getUnderlyingPrice(auTokenAddress).catch((e: any) => {
-    console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
-    return BN.from(0);
-  });
+  );
+  const rawPrice = await oracleContract.callStatic
+    .getUnderlyingPrice(auTokenAddress)
+    .catch((e: any) => {
+      console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
+      return BN.from(0);
+    });
 
   // In case of error, probally it is because the underlying token is not supported
   // by the backup oracle. In that case, we will fetch from third-party.
@@ -259,16 +262,12 @@ export async function fetchUnderlyingTokensPrices(provider: providers.Provider):
     underlyingPrice: BigNumber;
   }[]
 > {
-  const auriLens: Contract = new Contract(
-    networkAddresses.misc.AURILENS,
-    AuriLensABI.abi,
-    provider
-  );
+  const auriLens = createContract(networkAddresses.misc.AURILENS, AuriLensABI.abi, provider);
   const auTokenAddresses = networkAddresses.auTokens.map((auToken) => auToken.address);
   const underlyingDecimals = networkAddresses.auTokens.map((auToken) =>
     getDecimal(auToken.underlying)
   );
-  const rawPrices = await auriLens.auTokenUnderlyingPriceAll(auTokenAddresses);
+  const rawPrices = await auriLens.callStatic.auTokenUnderlyingPriceAll(auTokenAddresses);
   return rawPrices.map((res: any, ind: number) => {
     return {
       auToken: res.auToken,
@@ -280,7 +279,6 @@ export async function fetchUnderlyingTokensPrices(provider: providers.Provider):
 function shouldFetchFromKyberSwap(address: string) {
   address = address.toLowerCase();
   return (
-    address == networkAddresses.tokens.AURORA ||
     address == networkAddresses.tokens.TRI ||
     address == networkAddresses.tokens.META ||
     address == networkAddresses.tokens.STADER

package/src/interactors/Airdrop.ts

@@ -22,7 +22,7 @@ export class AirdropRead extends BlockchainEntityRead {
   ): Promise<TokenAmount> {
     let tokenInstance: Token = new Token(token, helpers.getDecimal(token));
 
-    let rewards: BN = await this.env.auriAirdrop.getRedeemableReward(
+    let rewards: BN = await this.env.auriAirdrop.raw.getRedeemableReward(
       utils.formatBytes32String(campaign),
       token,
       user
@@ -44,7 +44,7 @@ export class AirdropReadWrite extends AirdropRead {
       campaigns.length == tokens.length,
       'campaigns and tokens must have the same length'
     );
-    return this.env.auriAirdrop.connect(this._networkConnection.signer!).redeem(
+    return this.env.auriAirdrop.raw.connect(this._networkConnection.signer!).redeem(
       campaigns.map((e) => utils.formatBytes32String(e)),
       tokens,
       await this._networkConnection.signer!.getAddress()

package/src/interactors/MoneyMarket.ts

@@ -2,7 +2,7 @@ import { AuETH, AuErc20, EthRepayHelper } from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
 import { CacheType, cache } from 'cache-decorator';
-import { BigNumber as BN, Contract } from 'ethers';
+import { BigNumber as BN } from 'ethers';
 import * as abis from '../abis';
 import * as consts from '../consts';
 import { CACHE_TIMEOUT, ONE_DAY } from '../consts';
@@ -15,8 +15,9 @@ import {
   TokenAmount,
 } from '../entities';
 import * as helpers from '../helpers';
+import { createContract } from '../helpers/multicall';
 import { calcValuation, fetchPrice, fetchValuation } from '../helpers/priceFetcher';
-import { Address, Apy, MoneyMarketDetails, NetworkConnection } from '../types';
+import { Address, Apy, MoneyMarketDetails, MulticallStatic, NetworkConnection } from '../types';
 
 type RewardSpeeds = {
   plyRewardSupplySpeed: BN;
@@ -27,19 +28,19 @@ type RewardSpeeds = {
 
 export class MoneyMarketRead extends BlockchainEntityRead {
   public underlying: Token;
-  public auToken: AuErc20 | AuETH;
+  public auToken: MulticallStatic<AuErc20 | AuETH>;
   public readonly env: AuriEnv;
   constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
     super(networkConnection);
     this.env = new AuriEnv(networkConnection);
     if (helpers.isSameAddress(underlyingAsset, consts.ETHAddress)) {
-      this.auToken = new Contract(auToken, abis.AuETHABI.abi, networkConnection.provider) as AuETH;
+      this.auToken = createContract<AuETH>(auToken, abis.AuETHABI.abi, networkConnection.provider);
     } else {
-      this.auToken = new Contract(
+      this.auToken = createContract<AuErc20>(
         auToken,
         abis.AuErc20ABI.abi,
         networkConnection.provider
-      ) as AuErc20;
+      );
     }
     this.underlying = new Token(underlyingAsset, helpers.getDecimal(underlyingAsset));
   }
@@ -56,7 +57,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
   @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
   protected async getRewardSpeeds(): Promise<RewardSpeeds> {
-    var speeds = await this.env.auriLens.getRewardSpeeds(
+    var speeds = await this.env.auriLens.callStatic.getRewardSpeeds(
       this.env.comptroller.address,
       this.auToken.address
     );
@@ -65,14 +66,17 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
   @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
   public async getTotalTokenBorrowed(): Promise<TokenAmount> {
-    return new TokenAmount(this.underlying, (await this.auToken.totalBorrows()).toString());
+    return new TokenAmount(
+      this.underlying,
+      (await this.auToken.callStatic.totalBorrows()).toString()
+    );
   }
 
   @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
   public async getTotalTokenDeposited(): Promise<TokenAmount> {
     const [totalBorrow, totalCash] = await Promise.all([
       this.getTotalTokenBorrowed(),
-      this.auToken.getCash(),
+      this.auToken.callStatic.getCash(),
     ]);
     return new TokenAmount(
       this.underlying,
@@ -84,7 +88,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
   @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
   public async getDepositAPY(): Promise<BigNumber> {
-    const supplyRatePerTimestamp = await this.auToken.supplyRatePerTimestamp();
+    const supplyRatePerTimestamp = await this.auToken.callStatic.supplyRatePerTimestamp();
     const supplyRatePerDay = new BigNumber(supplyRatePerTimestamp.toString())
       .multipliedBy(ONE_DAY)
       .div(helpers.decimalFactor(18));
@@ -94,7 +98,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
   @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
   public async getBorrowAPY(): Promise<BigNumber> {
-    const borrowRatePerTimestamp = await this.auToken.borrowRatePerTimestamp();
+    const borrowRatePerTimestamp = await this.auToken.callStatic.borrowRatePerTimestamp();
     const borrowRatePerDay = new BigNumber(borrowRatePerTimestamp.toString())
       .multipliedBy(ONE_DAY)
       .div(helpers.decimalFactor(18));
@@ -103,7 +107,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
   @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
   public async getCollateralRatio(): Promise<BigNumber> {
-    return this.env.comptroller.markets(this.auToken.address).then((res: any) => {
+    return this.env.comptroller.callStatic.markets(this.auToken.address).then((res: any) => {
       return new BigNumber(res.collateralFactorMantissa.toString()).div(helpers.decimalFactor(18));
     });
   }
@@ -318,13 +322,13 @@ export class MoneyMarketRead extends BlockchainEntityRead {
   public async mintCap(): Promise<TokenAmount> {
     return new TokenAmount(
       this.underlying,
-      (await this.env.comptroller.mintCaps(this.auToken.address)).toString()
+      (await this.env.comptroller.callStatic.mintCaps(this.auToken.address)).toString()
     );
   }
   public async borrowCap(): Promise<TokenAmount> {
     return new TokenAmount(
       this.underlying,
-      (await this.env.comptroller.borrowCaps(this.auToken.address)).toString()
+      (await this.env.comptroller.callStatic.borrowCaps(this.auToken.address)).toString()
     );
   }
 
@@ -404,60 +408,60 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 }
 
 export class MoneyMarketReadWrite extends MoneyMarketRead {
-  protected _EthRepayHelper: EthRepayHelper;
+  protected _EthRepayHelper: MulticallStatic<EthRepayHelper>;
   constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
     super(networkConnection, auToken, underlyingAsset);
-    this._EthRepayHelper = new Contract(
+    this._EthRepayHelper = createContract<EthRepayHelper>(
       consts.networkAddresses.misc.ETHREPAYHELPER,
       abis.EthRepayHelperABI.abi,
       networkConnection.provider
-    ) as EthRepayHelper;
+    );
   }
 
   public async deposit(amount: TokenAmount): Promise<TransactionResponse> {
     if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
-      return (this.auToken as AuETH)
+      return (this.auToken.raw as AuETH)
         .connect(this._networkConnection.signer!)
         .mint({ value: amount.rawAmount() });
     } else {
-      return (this.auToken as AuErc20)
+      return (this.auToken.raw 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());
+    return this.auToken.raw.connect(this._networkConnection.signer!).borrow(amount.rawAmount());
   }
   public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
     if (new BigNumber(amount.rawAmount()).lt(0)) {
-      return this.auToken.connect(this._networkConnection.signer!).redeemUnderlying(consts.INF);
+      return this.auToken.raw.connect(this._networkConnection.signer!).redeemUnderlying(consts.INF);
     }
-    return this.auToken
+    return this.auToken.raw
       .connect(this._networkConnection.signer!)
       .redeemUnderlying(amount.rawAmount());
   }
   public async repay(amount: TokenAmount): Promise<TransactionResponse> {
     if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
-      return this._EthRepayHelper
+      return this._EthRepayHelper.raw
         .connect(this._networkConnection.signer!)
         .repayBorrow({ value: amount.rawAmount() });
     } else {
       if (new BigNumber(amount.rawAmount()).lt(0)) {
-        return this.auToken.connect(this._networkConnection.signer!).repayBorrow(consts.INF);
+        return this.auToken.raw.connect(this._networkConnection.signer!).repayBorrow(consts.INF);
       } else {
-        return this.auToken
+        return this.auToken.raw
           .connect(this._networkConnection.signer!)
           .repayBorrow(amount.rawAmount());
       }
     }
   }
   public async enableCollateral(): Promise<TransactionResponse> {
-    return this.env.comptroller
+    return this.env.comptroller.raw
       .connect(this._networkConnection.signer!)
       .enterMarkets([this.auToken.address]);
   }
   public async disableCollateral(): Promise<TransactionResponse> {
-    return this.env.comptroller
+    return this.env.comptroller.raw
       .connect(this._networkConnection.signer!)
       .exitMarket(this.auToken.address);
   }

package/src/interactors/Multicall.ts

@@ -4,7 +4,7 @@ import { Result } from 'ethers/lib/utils';
 import * as abis from '../abis';
 import * as consts from '../consts';
 import { BlockchainEntityRead } from '../entities';
-import { NetworkConnection } from '../types';
+import { MulticallStatic, NetworkConnection } from '../types';
 
 export class MulticallRead extends BlockchainEntityRead {
   public readonly multicall: Multicall2;
@@ -22,7 +22,7 @@ export class MulticallRead extends BlockchainEntityRead {
    */
   public async aggregate(
     calls: {
-      contract: Contract;
+      contract: MulticallStatic<Contract>;
       method: string;
       args: any[];
       returnTypes: string[];
@@ -32,7 +32,7 @@ export class MulticallRead extends BlockchainEntityRead {
     // prepare transactions
     for (let i = 0; i < calls.length; i++) {
       const call = calls[i];
-      let txn = await call.contract.populateTransaction[call.method](...call.args);
+      let txn = await call.contract.raw.populateTransaction[call.method](...call.args);
       txns.push({ target: txn.to!, callData: txn.data! });
     }
 

package/src/interactors/Papermill.ts

@@ -24,12 +24,12 @@ export class PapermillRead extends BlockchainEntityRead {
   }
 
   public async getPlyBalance(userAddress: Address): Promise<TokenAmount> {
-    const plyBalance = await this.env.ply.balanceOf(userAddress);
+    const plyBalance = await this.env.ply.raw.balanceOf(userAddress);
     return new TokenAmount(this.plyToken, plyBalance.toString());
   }
 
   public async getPulpBalance(userAddress: Address): Promise<TokenAmount> {
-    const pulpBalance = await this.env.pulp.balanceOf(userAddress);
+    const pulpBalance = await this.env.pulp.raw.balanceOf(userAddress);
     return new TokenAmount(this.pulpToken, pulpBalance.toString());
   }
 
@@ -37,7 +37,7 @@ export class PapermillRead extends BlockchainEntityRead {
    * 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(
+    let rewardBalancesMetadata = await this.env.auriLens.raw.callStatic.claimRewards(
       this.env.comptroller.address,
       this.env.auriFairLaunch.address,
       consts.ALL_STAKING_POOLS,
@@ -60,8 +60,8 @@ export class PapermillRead extends BlockchainEntityRead {
     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.env.auriLens.raw.getPercentLock(this.env.pulp.address, userAddress, currentWeek),
+      this.env.auriLens.raw.getPercentLock(this.env.pulp.address, userAddress, currentWeek + 1),
       this.getUnclaimedPlyReward(userAddress),
     ]);
 
@@ -69,7 +69,7 @@ export class PapermillRead extends BlockchainEntityRead {
     let percentLockNextWeek = BN.from(values[1]);
     let totalRewards = values[2] as TokenAmount;
 
-    let [pulpAmountCurrentWeek, plyAmountCurrentWeek] = await this.env.pulp.calcLockAmount(
+    let [pulpAmountCurrentWeek, plyAmountCurrentWeek] = await this.env.pulp.raw.calcLockAmount(
       userAddress,
       totalRewards.rawAmount()
     );
@@ -109,7 +109,7 @@ export class PapermillRead extends BlockchainEntityRead {
     userAddress: Address,
     targetUnlockPortion: number
   ): Promise<number> {
-    let weekId = await this.env.auriLens.getWeekToUnlock(
+    let weekId = await this.env.auriLens.raw.getWeekToUnlock(
       this.env.pulp.address,
       userAddress,
       targetUnlockPortion * 100
@@ -131,7 +131,7 @@ export class PapermillRead extends BlockchainEntityRead {
   }
 
   public async getUnlockPortionAt(userAddress: Address, timestamp: number): Promise<number> {
-    let lockPortion = await this.env.auriLens.getPercentLock(
+    let lockPortion = await this.env.auriLens.raw.getPercentLock(
       this.env.pulp.address,
       userAddress,
       this.getWeek(timestamp)
@@ -155,7 +155,7 @@ export class PapermillReadWrite extends PapermillRead {
    * Set to ethers.constants.MaxUint256 for max redeem.
    */
   public async redeem(recipient: Address, amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.pulp
+    return this.env.pulp.raw
       .connect(this._networkConnection.signer!)
       .redeem(recipient, amount.rawAmount());
   }