@aurigami/sdk 1.6.0-no-src → 1.6.0

package/src/contracts/airdrop-lottery.ts

@@ -0,0 +1,320 @@
+import AuriAirdropABI from '@aurigami/contracts/artifacts/contracts/AuriAirdrop.sol/AuriAirdrop.json';
+import { AuriAirdrop } from '@aurigami/contracts/typechain';
+import {
+  Provider,
+  TransactionResponse,
+} from '@ethersproject/abstract-provider';
+import { BigNumber as BN, Contract, utils } from 'ethers';
+import * as consts from '../consts';
+import {
+  BlockchainEntity,
+  BlockchainEntityRead,
+  Token,
+  TokenAmount,
+} from '../entities';
+import * as helpers from '../helpers';
+import AIRDROP_AUTOKEN_INFO from '../misc/airdrop_misc/auTokensInfo.json';
+import AIRDROP_WHITELIST_ADDRESSES from '../misc/airdrop_misc/whitelist.json';
+import { Address, NetworkConnection } from '../types';
+
+type AirdropUnderlyingInfo = {
+  minDeposit: BN;
+};
+
+type AirdropAuTokenInfo = {
+  address: string;
+  exchangeRate: BN;
+  deploymentBlock: number;
+  underlying: AirdropUnderlyingInfo;
+};
+
+class AirdropSettings {
+  private static _instance: AirdropSettings;
+
+  airdropStartBlock: number = 0;
+  airdropEndBlock: number = 0;
+  airdropStartTimestamp: number = consts.AIRDROP_START_TIMESTAMP;
+  airdropEndTimestamp: number = consts.AIRDROP_END_TIMESTAMP;
+  airdropThreshold: number = consts.AIRDROP_KEEP_THRESHOLD;
+  private constructor() {}
+
+  public static async getSettings(
+    provider: Provider
+  ): Promise<AirdropSettings> {
+    if (this._instance) return this._instance;
+
+    let settings: AirdropSettings = new AirdropSettings();
+
+    settings.airdropStartBlock = await helpers.getBlockBeforeTimestamp(
+      provider,
+      settings.airdropStartTimestamp
+    );
+
+    settings.airdropEndBlock = await helpers.getBlockBeforeTimestamp(
+      provider,
+      settings.airdropEndTimestamp
+    );
+
+    this._instance = settings;
+    return settings;
+  }
+}
+
+class AirdropAuTokenKeepTracker extends BlockchainEntityRead {
+  private _transferQuery: helpers.TransferEventQuery;
+  private _airdropAuTokenInfo: AirdropAuTokenInfo;
+  public constructor(
+    networkConnection: NetworkConnection,
+    airdropAuTokenInfo: AirdropAuTokenInfo
+  ) {
+    super(networkConnection);
+    this._transferQuery = new helpers.TransferEventQuery(
+      airdropAuTokenInfo.address,
+      networkConnection
+    );
+    this._airdropAuTokenInfo = airdropAuTokenInfo;
+
+    // exchangeRate = 102% * exchangeRate, see why in the comment of _toUnderlyingValue
+    this._airdropAuTokenInfo.exchangeRate =
+      this._airdropAuTokenInfo.exchangeRate.add(
+        this._airdropAuTokenInfo.exchangeRate.div(50)
+      );
+  }
+
+  /**
+   * Convert the given amount of auToken to the underlying value with the stored exchange rate
+   *
+   * Why we need to do this?
+   *
+   * By transfer event, we cannot know the exact underlying, the only
+   * info that we can keep track of via transfer is event is the auToken amount. So we need to
+   * convert it to the underlying value with the stored exchange rate.
+   *
+   * However, we cannot just simply use auTokenAmount * exchangeRate, because the exchange rate
+   * is changing over time. As advice of the contract team, use fixed exchangeRate * 102% is good enough.
+   *
+   */
+  private _toUnderlyingValue(auTokenAmount: BN): BN {
+    return auTokenAmount
+      .mul(this._airdropAuTokenInfo.exchangeRate)
+      .div(BN.from(10).pow(18));
+  }
+
+  /**
+   * Check if the user has been deposit at least (minDeposit) and keep it for
+   * more than AIRDROP_KEEP_THRESHOLD milliseconds
+   *
+   * How it works:
+   *  Whenever the user balance is exceed minDeposit, we will record the timestamp,
+   * and when the balance is below minDeposit, we will compare with the saved timestamp to see
+   * whether it has been keep for more than AIRDROP_KEEP_THRESHOLD milliseconds.
+   *
+   */
+  public async isEligible(address: string): Promise<boolean> {
+    const settings = await AirdropSettings.getSettings(
+      this._networkConnection.provider
+    );
+    const minDeposit = this._airdropAuTokenInfo.underlying.minDeposit;
+
+    // Get user balance at the time of Airdrop start
+    let balance = await this._transferQuery.queryERC20BalanceAt(
+      address,
+      settings.airdropStartBlock - 1
+    );
+
+    const [BELOW, ABOVE] = [false, true];
+    let flag = BELOW;
+    // variable to store the last timestamp that, from it to "current" timestamp,
+    // the balance is always above minDeposit
+    let lastEligibleBalanceTimestamp = 0;
+
+    if (this._toUnderlyingValue(balance).gte(minDeposit)) {
+      lastEligibleBalanceTimestamp = settings.airdropStartTimestamp;
+      flag = ABOVE;
+    }
+
+    let events = await this._transferQuery.queryERC20TransfersOf(
+      address,
+      settings.airdropStartBlock,
+      settings.airdropEndBlock
+    );
+
+    for (let { from, to, amount, blockNumber } of events) {
+      if (helpers.isSameAddress(from, address)) {
+        balance = balance.sub(amount);
+      }
+      if (helpers.isSameAddress(to, address)) {
+        balance = balance.add(amount);
+      }
+
+      // if it is different from the flag, that means the balance is changing
+      if (this._toUnderlyingValue(balance).gte(minDeposit) != flag) {
+        flag = !flag;
+        const timestamp = (
+          await this._networkConnection.provider.getBlock(blockNumber)
+        ).timestamp;
+
+        // if this txn make the balance below the minDeposit,
+        // check whether it has been keep for more than AIRDROP_KEEP_THRESHOLD
+        if (flag == BELOW) {
+          if (
+            timestamp - lastEligibleBalanceTimestamp >=
+            settings.airdropThreshold
+          ) {
+            return true;
+          }
+          lastEligibleBalanceTimestamp = 0;
+        } else {
+          // record the timestamp when the balance is above minDeposit
+          lastEligibleBalanceTimestamp = timestamp;
+        }
+      }
+    }
+
+    // if after the last txn, the balance is still above minDeposit,
+    // we should check from the last timestamp to "now"
+    if (flag == ABOVE) {
+      const timestamp = Math.min(
+        settings.airdropEndTimestamp,
+        helpers.getCurrentTimestamp()
+      );
+      return (
+        timestamp - lastEligibleBalanceTimestamp >= settings.airdropThreshold
+      );
+    }
+
+    return false;
+  }
+}
+
+export class AirdropRead extends BlockchainEntityRead {
+  protected _airDrop: AuriAirdrop;
+  private _whitelistedAddresses: Set<string>;
+  private keepTrackers: AirdropAuTokenKeepTracker[] = [];
+  public constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this._airDrop = new Contract(
+      consts.networkAddresses.misc.AURI_AIRDROP,
+      AuriAirdropABI.abi,
+      networkConnection.provider
+    ) as AuriAirdrop;
+
+    this._whitelistedAddresses = new Set(
+      (AIRDROP_WHITELIST_ADDRESSES as string[]).map((e) =>
+        e.toLocaleLowerCase()
+      )
+    );
+
+    let auTokens: any = AIRDROP_AUTOKEN_INFO;
+
+    for (let auToken in auTokens) {
+      let { address, exchangeRate, deploymentBlock, underlying } =
+        auTokens[auToken];
+
+      let airdropInfo: AirdropAuTokenInfo = {
+        address: address,
+        exchangeRate: BN.from(exchangeRate),
+        deploymentBlock: parseInt(deploymentBlock),
+        underlying: {
+          minDeposit: BN.from(underlying.minDeposit),
+        },
+      };
+
+      this.keepTrackers.push(
+        new AirdropAuTokenKeepTracker(networkConnection, airdropInfo)
+      );
+    }
+  }
+
+  public countWhitelistedAddresses(): number {
+    return this._whitelistedAddresses.size;
+  }
+
+  public isWhitelisted(user: string): boolean {
+    return this._whitelistedAddresses.has(user.toLocaleLowerCase());
+  }
+
+  public async hasCompletedChallenge(user: string): Promise<boolean> {
+    const settings = await AirdropSettings.getSettings(
+      this._networkConnection.provider
+    );
+
+    if (helpers.getCurrentTimestamp() < settings.airdropStartTimestamp) {
+      return false;
+    }
+
+    if (!this.isWhitelisted(user)) {
+      return false;
+    }
+
+    // iterate for all the market and check if the user has completed the challenge
+    return (
+      await Promise.all(
+        this.keepTrackers.map(async (keepTracker) => {
+          return keepTracker.isEligible(user);
+        })
+      )
+    ).includes(true);
+  }
+
+  /**
+   * 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);
+  }
+}

package/src/contracts/index.ts

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

package/src/entities/BlockchainEntity.ts

@@ -0,0 +1,33 @@
+import { Signer } from '@ethersproject/abstract-signer';
+import { NetworkConnection } from '../types';
+
+export class BlockchainEntityRead {
+  protected _networkConnection: NetworkConnection;
+  public constructor(networkConnection: NetworkConnection) {
+    this._networkConnection = networkConnection;
+  }
+}
+
+export class BlockchainEntityReadWrite extends BlockchainEntityRead {
+  public constructor(networkConnection: NetworkConnection) {
+    if (!(networkConnection.signer instanceof Signer)) {
+      throw Error(
+        'Signer is not provided when constructing BlockchainEntityReadWrite'
+      );
+    }
+    super(networkConnection);
+  }
+}
+
+export class BlockchainEntity {
+  constructor() {}
+  public read(networkConnection: NetworkConnection): BlockchainEntityRead {
+    return new BlockchainEntityRead(networkConnection);
+  }
+
+  public readWrite(
+    networkConnection: NetworkConnection
+  ): BlockchainEntityReadWrite {
+    return new BlockchainEntityReadWrite(networkConnection);
+  }
+}

package/src/entities/index.ts

@@ -0,0 +1,3 @@
+export * from './BlockchainEntity';
+export * from './token';
+export * from './tokenAmount';

package/src/entities/token.ts

@@ -0,0 +1,21 @@
+import { getDecimal } from '../helpers/helpers';
+import { networkAddresses } from '../consts/constants';
+
+export class Token {
+  public readonly address: string;
+  public readonly decimals: number;
+  public constructor(address: string, decimals: number) {
+    this.address = address.toLowerCase();
+    this.decimals = decimals;
+  }
+}
+
+export const PLYToken = new Token(
+  networkAddresses.tokens.PLY,
+  getDecimal(networkAddresses.tokens.PLY)
+);
+
+export const PLYWNEARToken = new Token(
+  networkAddresses.tokens.PLYWNEAR,
+  getDecimal(networkAddresses.tokens.PLYWNEAR)
+);

package/src/entities/tokenAmount.ts

@@ -0,0 +1,42 @@
+import { Token } from './token';
+import BigNumber from 'bignumber.js';
+import { decimalFactor, getDecimal } from '../helpers/helpers';
+import { Address } from '../types';
+
+export class TokenAmount {
+  public readonly token: Token;
+  private rawAmnt: string;
+
+  public constructor(token: Token, amount: string, isRaw: boolean = true) {
+    if (isRaw) {
+      this.rawAmnt = amount;
+    } else {
+      this.rawAmnt = new BigNumber(amount)
+        .times(decimalFactor(token.decimals))
+        .toFixed(0);
+    }
+    this.token = token;
+  }
+
+  public formattedAmount(): string {
+    return new BigNumber(this.rawAmnt)
+      .div(decimalFactor(this.token.decimals))
+      .toString();
+  }
+
+  public rawAmount(): string {
+    return this.rawAmnt;
+  }
+
+  public static fromAddressAndAmount(
+    tokenAddress: Address,
+    amount: string,
+    isRaw: boolean = true
+  ): TokenAmount {
+    return new TokenAmount(
+      new Token(tokenAddress, getDecimal(tokenAddress)),
+      amount,
+      isRaw
+    );
+  }
+}

package/src/helpers/aurora-api-helpers.ts

@@ -0,0 +1,20 @@
+import axios from 'axios';
+
+const AURORA_API_BASE_URL = 'https://api.aurorascan.dev/api';
+
+export async function getQuery(
+  module: string,
+  action: string,
+  params: Record<string, any> = {}
+): Promise<any> {
+  params = { ...params, module: module, action: action };
+
+  let resp = await axios.get(
+    AURORA_API_BASE_URL + '?' + new URLSearchParams(params),
+    {
+      headers: { 'Content-Type': 'application/json' },
+    }
+  );
+
+  return resp.data.result!;
+}

package/src/helpers/helpers.ts

@@ -0,0 +1,97 @@
+import { Provider } from '@ethersproject/abstract-provider';
+import BigNumber from 'bignumber.js';
+import { BigNumber as BN, utils } from 'ethers';
+import { getQuery as getAuroraAPIQuery } from './aurora-api-helpers';
+import { decimalRecords } from '../consts/decimals';
+import { Address } from '../types';
+
+export function assert(condition: boolean, message: string = ''): void {
+  if (!condition) {
+    message = 'Assertion failed' + (message ? ': ' + message : '');
+    throw new Error(message);
+  }
+}
+
+export function formatObject(object: Object) {
+  return JSON.stringify(object, null, '  ');
+}
+
+export function decimalFactor(decimal: number) {
+  return BN.from(10).pow(decimal).toString();
+}
+
+export const isSameAddress = (
+  address1: Address,
+  address2: Address
+): boolean => {
+  return address1.toLowerCase() == address2.toLowerCase();
+};
+
+export const getCurrentTimestamp = (): number => {
+  return Math.trunc(Date.now() / 1000);
+};
+
+export function validateAndParseAddress(address: Address): Address {
+  try {
+    return utils.getAddress(address);
+  } catch (error) {
+    throw new Error('Invalid address: ' + address);
+  }
+}
+
+export function getDecimal(address: Address): number {
+  let addressLowercase = address.toLowerCase();
+  assert(
+    decimalRecords[addressLowercase] != undefined,
+    'Decimal not found for ' + address
+  );
+  return decimalRecords[addressLowercase];
+}
+
+export function calcLMRewardApr(
+  rewardsValue: BigNumber,
+  totalStakeValue: BigNumber,
+  frequencyPerYear: number
+): BigNumber {
+  if (totalStakeValue.lte(0)) {
+    // avoid division by zero when there is no stake
+    return new BigNumber('999999999');
+  }
+  return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
+}
+
+export async function getBlockTimestamp(
+  provider: Provider,
+  blockNumber: number
+): Promise<number> {
+  const block = await provider.getBlock(blockNumber);
+  return block.timestamp;
+}
+
+/**
+ * Get the block number of the last block that has a timestamp before the given timestamp
+ * @param timestamp input timestamp
+ * @returns return the last block that its timestamp <= the give timestamp
+ * @note Check this API for more information: https://aurorascan.dev/apis#blocks
+ *
+ * This function is much faster than using binary search.
+ */
+export async function getBlockBeforeTimestamp(
+  provider: Provider,
+  timestamp: number
+) {
+  let result = await getAuroraAPIQuery('block', 'getblocknobytime', {
+    timestamp: timestamp,
+    closest: 'before',
+  });
+
+  // In case the API return `Block timestamp too far in the future`
+  // use the last block number
+  return parseInt(result) || (await provider.getBlockNumber());
+}
+
+export function devLog(message?: any, ...optionalParams: any[]): void {
+  if ('production' !== process.env.NODE_ENV) {
+    console.log(message, ...optionalParams);
+  }
+}

package/src/helpers/index.ts

@@ -0,0 +1,4 @@
+export * from './aurora-api-helpers';
+export * from './helpers';
+export * from './priceFetcher';
+export * from './transfer-event-query';