@aurigami/sdk 1.2.5 → 1.3.0

package/dist/transfer-event-query.d.ts

@@ -0,0 +1,17 @@
+import { BlockchainEntityRead } from "./BlockchainEntity";
+import { NetworkConnection } from "./types";
+import { AuToken } from "@aurigami/contracts/typechain";
+import { BigNumber as BN } from "ethers";
+declare type SimpleTransfer = {
+    from: string;
+    to: string;
+    amount: BN;
+    blockNumber: number;
+};
+export declare class TransferEventQuery extends BlockchainEntityRead {
+    auToken: AuToken;
+    constructor(tokenAddr: string, networkConnection: NetworkConnection);
+    queryERC20TransfersOf(address: string, fromBlock: number, toBlock: number): Promise<SimpleTransfer[]>;
+    queryERC20BalanceAt(address: string, endBlock: number): Promise<BN>;
+}
+export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.2.5",
+  "version": "1.3.0",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/airdrop-lottery.ts

@@ -0,0 +1,232 @@
+import { Provider } from "@ethersproject/abstract-provider";
+import { BlockchainEntity, BlockchainEntityRead } from "./BlockchainEntity";
+import { NetworkConnection } from "./types";
+import * as FileSystem from 'fs';
+import { BigNumber as BN } from "ethers";
+import { TransferEventQuery } from "./transfer-event-query";
+import { AIRDROP_START_TIMESTAMP, AIRDROP_KEEP_THRESHOLD, AIRDROP_END_TIMESTAMP } from "./constants";
+import { getBlockBeforeTimestamp, getCurrentTimestamp } from "./helpers";
+
+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 = 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,
+            63317969, //block number at the time I was writing this line, it's sure to be before the start of the airdrop
+        );
+
+        settings.airdropEndBlock = await getBlockBeforeTimestamp(
+            provider,
+            settings.airdropEndTimestamp,
+            settings.airdropStartBlock,
+        );
+
+        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));
+    }
+
+    /**
+     * 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 (from == address) {
+                balance = balance.sub(amount);
+            }
+            if (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;
+        }
+
+        return false;
+    }
+}
+
+export class AirdropRead extends BlockchainEntityRead {
+    private _whitelistedAddresses: Set<string>;
+    private keepTrackers: AirdropAuTokenKeepTracker[] = [];
+    public constructor(networkConnection: NetworkConnection) {
+        super(networkConnection);
+        this._whitelistedAddresses = new Set(
+            FileSystem.readFileSync("airdrop_misc/whitelist.txt").toString().trim().split('\n')
+        );
+
+        let auTokens = JSON.parse(
+            FileSystem.readFileSync("airdrop_misc/auTokensInfo.json").toString()
+        )
+
+        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
+                )
+            )
+        }
+    }
+
+    // this is for testing purpose only
+    public countWhitelistedAddresses(): number {
+        return this._whitelistedAddresses.size;
+    }
+
+    public isWhitelisted(user: string): boolean {
+        return this._whitelistedAddresses.has(user);
+    }
+
+    public async hasCompletedChallenge(user: string): Promise<boolean> {
+        const settings = await AirdropSettings.getSettings(this._networkConnection.provider);
+
+        if (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);
+    }
+}
+
+export class Airdrop extends BlockchainEntity {
+    constructor() {
+        super();
+    }
+    public read(networkConnection: NetworkConnection): AirdropRead {
+        return new AirdropRead(networkConnection);
+    }
+
+}

package/src/constants.ts

@@ -91,4 +91,9 @@ export const ONE_DAY = 86400;
 export const ONE_YEAR = ONE_DAY * 365;
 
 export const AurPlyPid = 0;
-export const INF = BN.from(2).pow(256).sub(1)
+export const INF = BN.from(2).pow(256).sub(1)
+
+
+export const AIRDROP_START_TIMESTAMP = 1649858400;
+export const AIRDROP_END_TIMESTAMP = 1651068000;
+export const AIRDROP_KEEP_THRESHOLD = 7 * 86400;

package/src/helpers.ts

@@ -1,7 +1,8 @@
+import { Provider } from "@ethersproject/abstract-provider";
 import BigNumber from "bignumber.js";
 import { BigNumber as BN, providers, utils } from "ethers";
 import { decimalRecords } from "./decimals";
-import { Address } from "./types";
+import { Address, NetworkConnection } from "./types";
 
 export function formatObject(object: Object) {
   return JSON.stringify(object, null, '  ');
@@ -36,3 +37,55 @@ export function calcLMRewardApr(rewardsValue: BigNumber, totalStakeValue: BigNum
   }
   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
+ *
+ * Note: For optimized reason, this function is not guaranteed to return the correct block number,
+ * it may differ from the actual block number at most 500 blocks.
+ */
+export async function getBlockBeforeTimestamp(provider: Provider, timestamp: number, startBlock?: number): Promise<number> {
+  // stop searching if the right - left < blockThreshold
+  const blockThreshold = 50 * 10; //50 is the average block in 1 minutes.
+  // Using K-search + promise all to speed up the search
+  const K = 8;
+
+  let leftBlock: number = (startBlock || 1);
+  let rightBlock = await provider.getBlockNumber();
+
+  if ((await getBlockTimestamp(provider, rightBlock)) < timestamp) {
+    return rightBlock;
+  }
+
+  while (rightBlock - leftBlock >= blockThreshold) {
+    let size = Math.floor((rightBlock - leftBlock + 1) / K);
+    let promises = [];
+
+    for (let i = 1; i < K; i++) {
+      promises.push(getBlockTimestamp(provider, leftBlock + i * size));
+    }
+
+    let blockTimestamps = await Promise.all(promises);
+    let nextLeftBlock = leftBlock;
+
+    for (let i = 1; i < K; i++) {
+      if (blockTimestamps[i - 1] <= timestamp) {
+        nextLeftBlock = leftBlock + i * size;
+      }
+    }
+
+    for (let i = K - 1; i >= 1; i--) {
+      if (blockTimestamps[i - 1] > timestamp) {
+        rightBlock = leftBlock + i * size - 1;
+      }
+    }
+
+    leftBlock = nextLeftBlock;
+  }
+  return leftBlock;
+}

package/src/index.ts

@@ -15,3 +15,5 @@ export * from './priceFetcher';
 export * from './token';
 export * from './tokenAmount';
 export * from './types';
+export * from './airdrop-lottery';
+export * from './transfer-event-query';

package/src/transfer-event-query.ts

@@ -0,0 +1,60 @@
+import { BlockchainEntityRead } from "./BlockchainEntity";
+import { NetworkConnection } from "./types";
+import { AuToken } from "@aurigami/contracts/typechain";
+import AuTokenABI from '@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json';
+import { BigNumber as BN, Contract } from "ethers";
+
+type SimpleTransfer = {
+    from: string;
+    to: string;
+    amount: BN;
+    blockNumber: number;
+}
+
+
+export class TransferEventQuery extends BlockchainEntityRead {
+    auToken: AuToken;
+
+    constructor(
+        tokenAddr: string,
+        networkConnection: NetworkConnection
+    ) {
+        super(networkConnection);
+        this.auToken = new Contract(tokenAddr, AuTokenABI.abi, this._networkConnection.provider) as AuToken;
+    }
+
+    /**
+     * query ERC20 transfers from/to an address & auto convert them into SimpleTransfer.
+     * The result will be sorted by blocknumber.
+     */
+    async queryERC20TransfersOf(address: string, fromBlock: number, toBlock: number): Promise<SimpleTransfer[]> {
+        const filters = [
+            this.auToken.filters.Transfer(address, null),
+            this.auToken.filters.Transfer(null, address)
+        ]
+
+        const events = (await Promise.all(filters.map(filter => this.auToken.queryFilter(filter, fromBlock, toBlock)))).flat();
+
+        let results: SimpleTransfer[] = events.map((event) => {
+            return {
+                from: event.args![0],
+                to: event.args![1],
+                amount: event.args![2],
+                blockNumber: event.blockNumber,
+            };
+        });
+
+        results.sort((a, b) => a.blockNumber - b.blockNumber);
+
+        return results;
+    }
+
+    /**
+     * Get the balance of an address at a given block number.
+     *
+     * Note that this will return the balance after the block get mined.
+     */
+    async queryERC20BalanceAt(address: string, endBlock: number): Promise<BN> {
+        return this.auToken.balanceOf(address, {blockTag: endBlock + 1});
+    }
+}