@aurigami/sdk 1.6.0 → 1.6.2

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.6.0",
+  "version": "1.6.2",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -60,7 +60,7 @@
     "typescript": "^4.5.4"
   },
   "dependencies": {
-    "@aurigami/contracts": "3.3.0",
+    "@aurigami/contracts": "3.5.0",
     "axios": "^0.26.1",
     "bignumber.js": "^9.0.2",
     "dotenv": "^16.0.0",

package/src/SDK.ts

@@ -2,10 +2,12 @@ import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairL
 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';
@@ -20,12 +22,14 @@ import {
 import {
   BlockchainEntity,
   BlockchainEntityRead,
+  PLYToken,
   Token,
   TokenAmount,
 } from './entities';
 import { decimalFactor, isSameAddress } from './helpers/helpers';
 import { calcValuation, fetchPrice } from './helpers/priceFetcher';
 import * as types from './types';
+import { MulticallRead } from './contracts/Multicall';
 
 export class SdkRead extends BlockchainEntityRead {
   protected _comptroller: Comptroller;
@@ -307,6 +311,68 @@ export class SdkRead extends BlockchainEntityRead {
         : newBorrowValuation!.div(newBorrowLimit!).toNumber(),
     };
   }
+
+  /**
+   * Get ply circulating supply.
+   * It is calculated by the total supply, minus:
+   *  - Ply in team multisig contract
+   *  - Ply in comptroller contract
+   *  - Ply in fairlaunch contract
+   *  - 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());
+  }
 }
 
 export class SdkReadWrite extends SdkRead {

package/src/consts/constants.ts

@@ -78,6 +78,10 @@ export const networkAddresses: NetworkAddresses = {
     AURILENS: MAINNET_ADDRESSES.auriLens.toLowerCase(),
     ETHREPAYHELPER: MAINNET_ADDRESSES.ethRepayHelper.toLowerCase(),
     AURI_AIRDROP: MAINNET_ADDRESSES.auriAirdrop.toLowerCase(),
+    MULTICALL: MAINNET_ADDRESSES.multicall.toLowerCase(),
+    TEAM_MULTISIG: '0x2D05FfFE70CE64c5954710D4C308dB31C8dBd8dE'.toLowerCase(),
+    PLY_TOKEN_LOCK: MAINNET_ADDRESSES.plyTokenLock.toLowerCase(),
+    REFERRAL: MAINNET_ADDRESSES.referralDirectory.toLocaleLowerCase(),
   },
   tokens: {
     AURORA: '0x8bec47865ade3b172a928df8f990bc7f2a3b9f79'.toLowerCase(),

package/src/contracts/Multicall.ts

@@ -0,0 +1,55 @@
+import Multicall2ABI from '@aurigami/contracts/artifacts/contracts/mock/Multicall2.sol/Multicall2.json';
+import { Multicall2 } from '@aurigami/contracts/typechain';
+import { Contract, ethers } from 'ethers';
+import * as consts from '../consts';
+import { BlockchainEntityRead } from '../entities';
+import { NetworkConnection } from '../types';
+import { Result } from 'ethers/lib/utils';
+
+export class MulticallRead extends BlockchainEntityRead {
+  protected _multicall: Multicall2;
+  constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this._multicall = new Contract(
+      consts.networkAddresses.misc.MULTICALL,
+      Multicall2ABI.abi,
+      networkConnection.provider
+    ) as Multicall2;
+  }
+
+  /**
+   * Run multiple calls via multicall contract
+   */
+  public async aggregate(
+    calls: {
+      contract: Contract;
+      method: string;
+      args: any[];
+      returnTypes: string[];
+    }[]
+  ): Promise<Result[]> {
+    const txns = [];
+    // prepare transactions
+    for (let i = 0; i < calls.length; i++) {
+      const call = calls[i];
+      let txn = await call.contract.populateTransaction[call.method](
+        ...call.args
+      );
+      txns.push({ target: txn.to!, callData: txn.data! });
+    }
+
+    const response = await this._multicall.callStatic.aggregate(txns);
+
+    // parse results
+    const decodedReturn = [];
+    for (let i = 0; i < calls.length; i++) {
+      decodedReturn.push(
+        ethers.utils.defaultAbiCoder.decode(
+          calls[i].returnTypes,
+          response.returnData[i]
+        )
+      );
+    }
+    return decodedReturn;
+  }
+}

package/src/contracts/Papermill.ts

@@ -104,6 +104,7 @@ export class PapermillRead extends BlockchainEntityRead {
       .div(consts.ONE_WEEK)
       .toNumber();
   }
+
   /**
    * Get all locking details of the user in all markets + all staking pools
    */
@@ -197,6 +198,18 @@ export class PapermillRead extends BlockchainEntityRead {
     return consts.REWARD_CLAIM_START + consts.ONE_WEEK * weekId.toNumber();
   }
 
+  /**
+   * Get the start timestamp of next week of the papermill contract.
+   *
+   * This is a sync function!
+   *
+   * @returns the timestamp in seconds
+   */
+  public getNextWeekTimestamp(): number {
+    const nextWeek = this.getWeek(helpers.getCurrentTimestamp()) + 1;
+    return consts.REWARD_CLAIM_START + consts.ONE_WEEK * nextWeek;
+  }
+
   public async getUnlockPortionAt(
     userAddress: Address,
     timestamp: number

package/src/contracts/Referral.ts

@@ -0,0 +1,98 @@
+import ReferralDirectoryABI from '@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json';
+import { ReferralDirectory } from '@aurigami/contracts/typechain';
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { Contract, ethers } from 'ethers';
+import * as consts from '../consts';
+import { BlockchainEntity, BlockchainEntityRead } from '../entities';
+import { Address, NetworkConnection } from '../types';
+
+export class ReferralRead extends BlockchainEntityRead {
+  protected _referral: ReferralDirectory;
+  constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this._referral = new Contract(
+      consts.networkAddresses.misc.REFERRAL,
+      ReferralDirectoryABI.abi,
+      networkConnection.provider
+    ) as ReferralDirectory;
+  }
+
+  /**
+   * Generate a 10-character referral code
+   * containing alphanumeric characters.
+   */
+  protected generateReferralCode(): string {
+    let letters = 'abcdefghijklmnopqrstuvwxyz';
+    let numbers = '1234567890';
+    let charset = letters + letters.toUpperCase() + numbers;
+    let R = '';
+    for (var i = 0; i < 10; i++)
+      R += charset[Math.floor(Math.random() * charset.length)];
+    return R;
+  }
+
+  /**
+   * Get the referral code for a given address, returns empty string if not found.
+   *
+   * Called to check if a user has a referral code.
+   */
+  public async getUserReferralCode(userAddr: Address): Promise<string> {
+    const result = await this._referral.userReferralCode(userAddr);
+    return ethers.utils.parseBytes32String(result);
+  }
+
+  /**
+   * Get referral code that a user was referred by, returns empty string if not found.
+   */
+  public async getReferralCodeUsed(userAddr: Address): Promise<string> {
+    const result = await this._referral.referralCodeUsed(userAddr);
+    return ethers.utils.parseBytes32String(result);
+  }
+
+  /**
+   * Get owner of a referral code, returns zero address if not found.
+   */
+  public async getReferralCodeOwner(code: string): Promise<Address> {
+    const referralCode = ethers.utils.formatBytes32String(code);
+    return this._referral.referralCodeOwner(referralCode);
+  }
+}
+
+export class ReferralReadWrite extends ReferralRead {
+  /**
+   * Generate a referral code for a given address.
+   *
+   * Called when an user want to creates his own referral code
+   */
+  public async registerNewReferralCode(): Promise<TransactionResponse> {
+    const referralCode = ethers.utils.formatBytes32String(
+      this.generateReferralCode()
+    );
+    return this._referral
+      .connect(this._networkConnection.signer!)
+      .registerNewUserReferralCode(referralCode);
+  }
+
+  /**
+   * Called when an user confirms he is referred by a specified code
+   */
+  public async useReferralCode(code: string): Promise<TransactionResponse> {
+    const referralCode = ethers.utils.formatBytes32String(code);
+    return this._referral
+      .connect(this._networkConnection.signer!)
+      .registerReferralCodeUsed(referralCode);
+  }
+}
+
+export class Referral extends BlockchainEntity {
+  constructor() {
+    super();
+  }
+  public read(networkConnection: NetworkConnection): ReferralRead {
+    return new ReferralRead(networkConnection);
+  }
+
+  public readWrite(networkConnection: NetworkConnection): ReferralReadWrite {
+    return new ReferralReadWrite(networkConnection);
+  }
+}

package/src/contracts/index.ts

@@ -1,4 +1,5 @@
 export * from './airdrop-lottery';
 export * from './MoneyMarket';
 export * from './Papermill';
+export * from './Referral';
 export * from './Staking';