@aurigami/sdk 1.2.6 → 1.3.1

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/priceFetcher.ts

@@ -116,7 +116,7 @@ function shouldFetchFromCoingecko(address: string) {
 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 (isSameAddress(address, networkAddresses.tokens.stNEAR)) return fetchStNEARPrice();
     if (shouldFetchFromCoingecko(address)) return fetchPriceFromCoingecko(address);
 
     const matchingAuToken = networkAddresses.auTokens.find((auToken) => {

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});
+    }
+}