@aurigami/sdk 1.7.0 → 1.7.2

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.7.0",
+  "version": "1.7.2",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -70,4 +70,4 @@
   "jest": {
     "testURL": "https://app.aurigami.finance"
   }
-}
+}

package/src/contracts/Referral.ts

@@ -1,6 +1,7 @@
 import { ReferralDirectory } from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import { Contract, ethers } from 'ethers';
+import { getBlocksTimestamp } from '..';
 import * as abis from '../abis';
 import * as consts from '../consts';
 import { BlockchainEntity, BlockchainEntityRead } from '../entities';
@@ -62,10 +63,11 @@ export class ReferralRead extends BlockchainEntityRead {
    */
   public async getReferralsList(userAddr: Address): Promise<{ user: string; timestamp: number }[]> {
     const result = await AuriAPI.getPaginatedApi('/referral/list', { address: userAddr });
-
-    const items = result.items.map((item) => ({
+    const blocks = result.items.map((item) => item.blockNumber!);
+    const blocksTimestamp = await getBlocksTimestamp(this._networkConnection.provider, blocks);
+    const items = result.items.map((item, i) => ({
       user: item.user!,
-      timestamp: item.blockNumber!, // @TODO: change this to timestamp
+      timestamp: blocksTimestamp[i],
     }));
     return items;
   }

package/src/helpers/graphql-helpers.ts

@@ -0,0 +1,10 @@
+import axios from 'axios';
+
+const GRAPHQL_URL = 'https://explorer.mainnet.aurora.dev/graphiql';
+
+export async function queryGraphQL(query: string): Promise<any> {
+  let resp = await axios.post(GRAPHQL_URL, {
+    query: query,
+  });
+  return resp.data.data!;
+}

package/src/helpers/helpers.ts

@@ -5,6 +5,7 @@ import { decimalRecords } from '../consts/decimals';
 import { symbolRecords } from '../consts/symbols';
 import { Address } from '../types';
 import { getQuery as getAuroraAPIQuery } from './aurora-api-helpers';
+import { queryGraphQL } from './graphql-helpers';
 
 export function assert(condition: boolean, message: string = ''): void {
   if (!condition) {
@@ -69,6 +70,61 @@ export async function getBlockTimestamp(provider: Provider, blockNumber: number)
   return block.timestamp;
 }
 
+export async function getBlocksTimestampViaRPC(
+  provider: Provider,
+  blocksNumber: number[]
+): Promise<number[]> {
+  // Promise all 200 blocks at a time, using too many blocks at once will cause the RPC call timeout.
+  const CHUNK_SIZE = 200;
+  let results: number[] = [];
+  for (let i = 0; i < blocksNumber.length; i += CHUNK_SIZE) {
+    let slice = blocksNumber.slice(i, i + CHUNK_SIZE);
+    let promises = slice.map(async (blockNumber) => getBlockTimestamp(provider, blockNumber));
+    results = results.concat(await Promise.all(promises));
+  }
+  return results;
+}
+
+/**
+ * Get timestamp of multiple blocks.
+ * @note the getBlockTimestamp function is too slow because of the RPC call, even with Promise.all.
+ * So I use the GraphQL endpoint of Aurora instead. You can check it here: https://explorer.mainnet.aurora.dev/graphiql
+ */
+export async function getBlocksTimestamp(
+  provider: Provider,
+  blockNumbers: number[]
+): Promise<number[]> {
+  const CHUNK_SIZE = 100; // graphql query limit
+
+  let promises = [];
+  let lines: string[] = blockNumbers.map((x) => `b${x}: block(number: ${x}) { timestamp }`);
+
+  for (let i = 0; i < lines.length; i += CHUNK_SIZE) {
+    let query = `{ ${lines.slice(i, i + CHUNK_SIZE).join('\n')} }`;
+    promises.push(queryGraphQL(query));
+  }
+
+  // merge all the json objects
+  let results = (await Promise.all(promises)).reduce((acc, cur) => {
+    return { ...acc, ...cur };
+  });
+
+  let missingBlocks = blockNumbers.filter((blockNumber) => !results[`b${blockNumber}`]);
+  if (missingBlocks.length > 0) {
+    devLog(`These blocks are missing from Aurora GraphQL endpoint: ${missingBlocks.join(', ')}`);
+  }
+
+  let missingBlocksTimestamps = await getBlocksTimestampViaRPC(provider, missingBlocks);
+
+  missingBlocksTimestamps.forEach((timestamp, index) => {
+    results[`b${missingBlocks[index]}`] = { timestamp: new Date(timestamp * 1000).toISOString() };
+  });
+
+  return blockNumbers.map((blockNumber) =>
+    Math.trunc(new Date(results[`b${blockNumber}`]!.timestamp).getTime() / 1000)
+  );
+}
+
 /**
  * Get the block number of the last block that has a timestamp before the given timestamp
  * @param timestamp input timestamp

package/src/helpers/index.ts

@@ -1,5 +1,6 @@
 export * from './aurigami-api';
 export * from './aurora-api-helpers';
+export * from './graphql-helpers';
 export * from './helpers';
 export * from './priceFetcher';
 export * from './transfer-event-query';