@aurigami/sdk 1.4.0 → 1.4.2

package/package.json

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

package/src/airdrop-lottery.ts

@@ -6,7 +6,7 @@ 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 } from "./helpers";
+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";
@@ -44,13 +44,11 @@ class 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;
@@ -129,10 +127,10 @@ class AirdropAuTokenKeepTracker extends BlockchainEntityRead {
         );
 
         for (let { from, to, amount, blockNumber } of events) {
-            if (from == address) {
+            if (isSameAddress(from, address)) {
                 balance = balance.sub(amount);
             }
-            if (to == address) {
+            if (isSameAddress(to, address)) {
                 balance = balance.add(amount);
             }
 

package/src/aurora-api-helpers.ts

@@ -0,0 +1,15 @@
+import fetch from 'node-fetch';
+
+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 fetch(AURORA_API_BASE_URL + '?' + new URLSearchParams(params), {
+        headers: { 'Content-Type': 'application/json' },
+        method: 'GET'
+    });
+    return (await resp.json()).result!;
+}

package/src/constants.ts

@@ -80,6 +80,7 @@ export const networkAddresses: NetworkAddresses = {
     USDC: '0xb12bfca5a55806aaf64e99521918a4bf0fc40802'.toLowerCase(),
     WNEAR: '0xC42C30aC6Cc15faC9bD938618BcaA1a1FaE8501d'.toLowerCase(),
     TRI: '0xFa94348467f64D5A457F75F8bc40495D33c65aBB'.toLowerCase(),
+    META: '0xc21ff01229e982d7c8b8691163b0a3cb8f357453'.toLocaleLowerCase(),
     AURPLY: dummyAddress.toLowerCase() // This is dummy
   }
 }

package/src/helpers.ts

@@ -3,6 +3,7 @@ import { EIP20Interface, IERC20 } from "@aurigami/contracts/typechain";
 import { Provider } from "@ethersproject/abstract-provider";
 import BigNumber from "bignumber.js";
 import { BigNumber as BN, Contract, providers, utils } from "ethers";
+import { getQuery as getAuroraAPIQuery } from "./aurora-api-helpers";
 import { decimalRecords } from "./decimals";
 import { Address, NetworkConnection } from "./types";
 
@@ -34,18 +35,6 @@ export function getDecimal(address: Address): number {
   return decimalRecords[address.toLowerCase()];
 }
 
-/**
- * Get the decimals of a token via EIP20Interface
- */
-export async function getDecimalsViaContract(address: Address, provider: Provider): Promise<number> {
-  let result = getDecimal(address);
-  if (result) {
-    return result;
-  }
-  let token: EIP20Interface = new Contract(address, EIP20InterfaceABI.abi, provider) as EIP20Interface;
-  return token.decimals();
-}
-
 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');
@@ -60,47 +49,20 @@ export async function getBlockTimestamp(provider: Provider, blockNumber: number)
 
 /**
  * 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
  *
- * 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.
+ * This function is much faster than using binary search.
  */
-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;
+ 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();
 }

package/src/priceFetcher.ts

@@ -17,7 +17,7 @@ export async function fetchPriceFromCoingeckoAPI(id: string): Promise<BigNumber>
     ).then((res: any) => {
       return res.data
     })
-  
+
     return new BigNumber(price[id].usd)
 }
 
@@ -28,7 +28,10 @@ export async function fetchPriceFromCoingecko(id: Address): Promise<BigNumber> {
 
         case networkAddresses.tokens.TRI:
             return fetchPriceFromCoingeckoAPI('trisolaris');
-        
+
+        case networkAddresses.tokens.META:
+            return fetchPriceFromCoingeckoAPI('meta-pool');
+
         default:
             throw Error(`Unknown token ${id} in fetchPriceFromCoingecko`);
     }
@@ -110,12 +113,13 @@ export async function fetchStNEARPrice(): Promise<BigNumber> {
 function shouldFetchFromCoingecko(address: string) {
     address = address.toLowerCase();
     return address == networkAddresses.tokens.AURORA ||
-           address == networkAddresses.tokens.TRI;
+           address == networkAddresses.tokens.TRI ||
+           address == networkAddresses.tokens.META;
 }
 
 export async function fetchPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
     if (hardcodePLYPrice && isSameAddress(address, networkAddresses.tokens.PLY)) return new BigNumber(0);
-    
+
     // if (isSameAddress(address, networkAddresses.tokens.stNEAR)) return fetchStNEARPrice();
     if (shouldFetchFromCoingecko(address)) return fetchPriceFromCoingecko(address);
 
@@ -124,7 +128,7 @@ export async function fetchPrice(address: Address, provider: providers.Provider)
     });
     if (matchingAuToken !== undefined) {
         return fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider);
-    } else if (isSameAddress(address, networkAddresses.tokens.AUPLYLP)) {
+    } else if (isSameAddress(address, networkAddresses.tokens.AURPLY)) {
         return fetchLPPrice(address, provider);
     } else {
         return fetchPriceFromCoingecko(address);
@@ -138,4 +142,4 @@ export async function fetchValuation(tokenAmount: TokenAmount, provider: provide
 
 export function calcValuation(tokenAmount: TokenAmount, price: BigNumber) {
     return new BigNumber(tokenAmount.formattedAmount()).multipliedBy(price);
-}
+}