@aurigami/sdk 1.4.8 → 1.5.0-dummy-1

package/src/airdrop-lottery.ts

@@ -1,282 +1,327 @@
-import { Provider } from "@ethersproject/abstract-provider";
+import { Provider } from '@ethersproject/abstract-provider';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { BlockchainEntity, BlockchainEntityRead } from "./BlockchainEntity";
-import { Address, NetworkConnection } from "./types";
-import { BigNumber as BN, Contract, utils } from "ethers";
-import { TransferEventQuery } from "./transfer-event-query";
-import { AIRDROP_START_TIMESTAMP, AIRDROP_KEEP_THRESHOLD, AIRDROP_END_TIMESTAMP, networkAddresses } from "./constants";
-import AuriAirdropABI from "@aurigami/contracts/artifacts/contracts/AuriAirdrop.sol/AuriAirdrop.json"
-import { getBlockBeforeTimestamp, getCurrentTimestamp, getDecimal, isSameAddress } from "./helpers";
-import AIRDROP_AUTOKEN_INFO from "./airdrop_misc/auTokensInfo.json"
-import AIRDROP_WHITELIST_ADDRESSES from "./airdrop_misc/whitelist.json"
-import { AuriAirdrop } from "@aurigami/contracts/typechain";
+import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
+import { Address, NetworkConnection } from './types';
+import { BigNumber as BN, Contract, utils } from 'ethers';
+import { TransferEventQuery } from './transfer-event-query';
+import {
+  AIRDROP_START_TIMESTAMP,
+  AIRDROP_KEEP_THRESHOLD,
+  AIRDROP_END_TIMESTAMP,
+  networkAddresses,
+} from './constants';
+import AuriAirdropABI from '@aurigami/contracts/artifacts/contracts/AuriAirdrop.sol/AuriAirdrop.json';
+import {
+  getBlockBeforeTimestamp,
+  getCurrentTimestamp,
+  getDecimal,
+  isSameAddress,
+} from './helpers';
+import AIRDROP_AUTOKEN_INFO from './airdrop_misc/auTokensInfo.json';
+import AIRDROP_WHITELIST_ADDRESSES from './airdrop_misc/whitelist.json';
+import { AuriAirdrop } from '@aurigami/contracts/typechain';
 import assert from 'assert';
-import { TokenAmount } from "./tokenAmount";
-import { Token } from "./token";
+import { TokenAmount } from './tokenAmount';
+import { Token } from './token';
 
 type AirdropUnderlyingInfo = {
-    minDeposit: BN,
-}
+  minDeposit: BN;
+};
 
 type AirdropAuTokenInfo = {
-    address: string,
-    exchangeRate: BN,
-    deploymentBlock: number,
-    underlying: AirdropUnderlyingInfo
-}
+  address: string;
+  exchangeRate: BN;
+  deploymentBlock: number;
+  underlying: AirdropUnderlyingInfo;
+};
 
 class AirdropSettings {
-    private static _instance: AirdropSettings;
-
-    airdropStartBlock: number = 0;
-    airdropEndBlock: number = 0;
-    airdropStartTimestamp: number = AIRDROP_START_TIMESTAMP;
-    airdropEndTimestamp: number = AIRDROP_END_TIMESTAMP;
-    airdropThreshold: number = 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 getBlockBeforeTimestamp(
-            provider,
-            settings.airdropStartTimestamp,
-        );
-
-        settings.airdropEndBlock = await getBlockBeforeTimestamp(
-            provider,
-            settings.airdropEndTimestamp,
-        );
-
-        this._instance = settings;
-        return settings;
-    }
+  private static _instance: AirdropSettings;
+
+  airdropStartBlock: number = 0;
+  airdropEndBlock: number = 0;
+  airdropStartTimestamp: number = AIRDROP_START_TIMESTAMP;
+  airdropEndTimestamp: number = AIRDROP_END_TIMESTAMP;
+  airdropThreshold: number = 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 getBlockBeforeTimestamp(
+      provider,
+      settings.airdropStartTimestamp
+    );
+
+    settings.airdropEndBlock = await getBlockBeforeTimestamp(
+      provider,
+      settings.airdropEndTimestamp
+    );
+
+    this._instance = settings;
+    return settings;
+  }
 }
 
 class AirdropAuTokenKeepTracker extends BlockchainEntityRead {
-    private _transferQuery: TransferEventQuery;
-    private _airdropAuTokenInfo: AirdropAuTokenInfo;
-    public constructor(networkConnection: NetworkConnection, airdropAuTokenInfo: AirdropAuTokenInfo) {
-        super(networkConnection);
-        this._transferQuery = new 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));
+  private _transferQuery: TransferEventQuery;
+  private _airdropAuTokenInfo: AirdropAuTokenInfo;
+  public constructor(
+    networkConnection: NetworkConnection,
+    airdropAuTokenInfo: AirdropAuTokenInfo
+  ) {
+    super(networkConnection);
+    this._transferQuery = new 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;
     }
 
-    /**
-     * 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 (isSameAddress(from, address)) {
-                balance = balance.sub(amount);
-            }
-            if (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, getCurrentTimestamp());
-            return timestamp - lastEligibleBalanceTimestamp >= settings.airdropThreshold;
+    let events = await this._transferQuery.queryERC20TransfersOf(
+      address,
+      settings.airdropStartBlock,
+      settings.airdropEndBlock
+    );
+
+    for (let { from, to, amount, blockNumber } of events) {
+      if (isSameAddress(from, address)) {
+        balance = balance.sub(amount);
+      }
+      if (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;
         }
-
-        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(
-            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
-                )
-            )
-        }
+    // 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,
+        getCurrentTimestamp()
+      );
+      return (
+        timestamp - lastEligibleBalanceTimestamp >= settings.airdropThreshold
+      );
     }
 
-    public countWhitelistedAddresses(): number {
-        return this._whitelistedAddresses.size;
-    }
+    return false;
+  }
+}
 
-    public isWhitelisted(user: string): boolean {
-        return this._whitelistedAddresses.has(user.toLocaleLowerCase());
+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(
+      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 async hasCompletedChallenge(user: string): Promise<boolean> {
-        const settings = await AirdropSettings.getSettings(this._networkConnection.provider);
+  public countWhitelistedAddresses(): number {
+    return this._whitelistedAddresses.size;
+  }
 
-        if (getCurrentTimestamp() < settings.airdropStartTimestamp) {
-            return false;
-        }
+  public isWhitelisted(user: string): boolean {
+    return this._whitelistedAddresses.has(user.toLocaleLowerCase());
+  }
 
-        if (!this.isWhitelisted(user)) {
-            return false;
-        }
+  public async hasCompletedChallenge(user: string): Promise<boolean> {
+    const settings = await AirdropSettings.getSettings(
+      this._networkConnection.provider
+    );
 
-        // 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);
+    if (getCurrentTimestamp() < settings.airdropStartTimestamp) {
+      return false;
     }
 
-    /**
-     * Get redeemable rewards amount of user
-     */
-    public async getRedeemableReward(campaign: string, token: Address, user: Address): Promise<TokenAmount> {
-        let tokenInstance: Token = new Token(
-            token,
-            getDecimal(token),
-        );
-
-        let rewards: BN = await this._airDrop.getRedeemableReward(
-            utils.formatBytes32String(campaign),
-            token,
-            user
-        )
-
-        return new TokenAmount(tokenInstance, rewards.toString());
+    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, 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> {
-        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]);
-    }
+  /**
+   * Transfer rewards from multiple campaigns to msg.sender
+   */
+  public async redeemMultiple(
+    campaigns: string[],
+    tokens: Address[]
+  ): Promise<TransactionResponse> {
+    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);
-    }
+  constructor() {
+    super();
+  }
+  public read(networkConnection: NetworkConnection): AirdropRead {
+    return new AirdropRead(networkConnection);
+  }
+  public readWrite(networkConnection: NetworkConnection): AirdropReadWrite {
+    return new AirdropReadWrite(networkConnection);
+  }
 }

package/src/aurora-api-helpers.ts

@@ -3,13 +3,18 @@ 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> = {},
+  module: string,
+  action: string,
+  params: Record<string, any> = {}
 ): Promise<any> {
-    params = {...params, 'module': module, 'action': action};
+  params = { ...params, module: module, action: action };
 
-    let resp = await axios.get(AURORA_API_BASE_URL + '?' + new URLSearchParams(params), {
-        headers: { 'Content-Type': 'application/json' }
-    });
+  let resp = await axios.get(
+    AURORA_API_BASE_URL + '?' + new URLSearchParams(params),
+    {
+      headers: { 'Content-Type': 'application/json' },
+    }
+  );
 
-    return resp.data.result!;
+  return resp.data.result!;
 }