@aurigami/sdk 1.2.6 → 1.3.1

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.6",
+  "version": "1.3.1",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/MoneyMarket.ts

@@ -211,7 +211,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
   
   private getDepositNEARRewardPerWeek(): TokenAmount {
     const NEARToken = new Token(networkAddresses.tokens.WNEAR, getDecimal(networkAddresses.tokens.WNEAR));
-    const rewardStopTime = 1649858400;
+    const rewardStopTime = 1649253600;
     if (isSameAddress(this.underlying.address, networkAddresses.tokens.USDC) && getCurrentTimestamp() <= rewardStopTime) {
       return new TokenAmount(NEARToken, "1250", false);
     } else {
@@ -221,7 +221,7 @@ export class MoneyMarketRead extends BlockchainEntityRead {
 
   private getBorrowNEARRewardPerWeek(): TokenAmount {
     const NEARToken = new Token(networkAddresses.tokens.WNEAR, getDecimal(networkAddresses.tokens.WNEAR));
-    const rewardStopTime = 1649858400;
+    const rewardStopTime = 1649253600;
     if (isSameAddress(this.underlying.address, networkAddresses.tokens.USDC) && getCurrentTimestamp() <= rewardStopTime) {
       return new TokenAmount(NEARToken, "3750", false);
     } else {

package/src/airdrop-lottery.ts

@@ -0,0 +1,229 @@
+import { Provider } from "@ethersproject/abstract-provider";
+import { BlockchainEntity, BlockchainEntityRead } from "./BlockchainEntity";
+import { NetworkConnection } from "./types";
+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";
+import AIRDROP_AUTOKEN_INFO from "./airdrop_misc/auTokensInfo.json"
+import AIRDROP_WHITELIST_ADDRESSES from "./airdrop_misc/whitelist.json"
+
+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(AIRDROP_WHITELIST_ADDRESSES as string[]);
+
+        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);
+    }
+
+    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/airdrop_misc/auTokensInfo.json

@@ -0,0 +1,34 @@
+{
+    "auUSDC": {
+        "address": "0x4f0d864b1ABf4B701799a0b30b57A22dFEB5917b",
+        "exchangeRate": "200810680770707",
+        "deploymentBlock": "60501576",
+        "underlying": {
+            "minDeposit": "1000000000"
+        }
+    },
+    "auETH": {
+        "address": "0xca9511B610bA5fc7E311FDeF9cE16050eE4449E9",
+        "exchangeRate": "200390813218617347858934298",
+        "deploymentBlock": "60501625",
+        "underlying": {
+            "minDeposit": "300000000000000000"
+        }
+    },
+    "auWBTC": {
+        "address": "0xCFb6b0498cb7555e7e21502E0F449bf28760Adbb",
+        "exchangeRate": "20050472926613996",
+        "deploymentBlock": "60501670",
+        "underlying": {
+            "minDeposit": "2000000"
+        }
+    },
+    "auUSDT": {
+        "address": "0xaD5A2437Ff55ed7A8Cad3b797b3eC7c5a19B1c54",
+        "exchangeRate": "200868369820223",
+        "deploymentBlock": "60501723",
+        "underlying": {
+            "minDeposit": "1000000000"
+        }
+    }
+}

package/src/airdrop_misc/whitelist.example.txt

@@ -0,0 +1,4 @@
+0x2b285e1b49ba0cb6f71d8b0d9cafdfbf9868fda9
+0xe8e9a0a2571299a0dabcaae98608352faf533e6a
+0xb3539af6596d8e08f75e96452d92bc17e3cdffc0
+0x0c5a5bd45078916ff5ff3acafeb19fe96fd747dc