Merge pull request #212 from layerx-labs/dev

BEPRO 2.25

Author: moshmage

package-lock.json

@@ -27,7 +27,7 @@
   "dependencies": {
     "@elastic/elasticsearch": "^8.2.1",
     "@sendgrid/mail": "^7.7.0",
-    "@taikai/dappkit": "^2.3.3",
+    "@taikai/dappkit": "^2.3.4",
     "@taikai/scribal": "^1.0.3",
     "axios": "^0.27.2",
     "bignumber.js": "9.1.0",

package.json

@@ -0,0 +1,33 @@
+import logger from "src/utils/logger-handler";
+import { EventsProcessed, EventsQuery } from "src/interfaces/block-chain-service";
+import { DecodedLog } from "src/interfaces/block-sniffer";
+import { NetworkParamChanged } from "@taikai/dappkit/dist/src/interfaces/events/network-v2-events";
+import { updateNetworkParameters } from "src/modules/update-network-params";
+
+export const name = "GetNetworkParamChanged";
+export const schedule = "0 0 * * *";
+export const description = "update network parameters on database";
+export const author = "Vitor Hugo";
+
+export async function action(block: DecodedLog<NetworkParamChanged['returnValues']>, query?: EventsQuery): Promise<EventsProcessed> {
+  const eventsProcessed: EventsProcessed = {};
+  const { address: networkAddress, chainId, connection } = block;
+
+  logger.info(`${name} start`);
+
+  try {
+    await updateNetworkParameters({
+      networkAddress,
+      chainId,
+      connection
+    });
+
+    eventsProcessed[networkAddress] = ["updated"];
+
+    logger.info(`${name} parameters saved ${networkAddress} ${chainId}`);
+  } catch (error: any) {
+    logger.error(`${name} Failed to save parameters of ${networkAddress} ${chainId}`, error?.message || error.toString());
+  }
+
+  return eventsProcessed;
+}

src/actions/get-network-param-changed.ts

@@ -1,91 +1,55 @@
 import db from "src/db";
 import logger from "src/utils/logger-handler";
-import {EventsProcessed, EventsQuery,} from "src/interfaces/block-chain-service";
-import {Network_v2, Web3Connection} from "@taikai/dappkit";
-import {Op} from "sequelize";
-import {getChainsRegistryAndNetworks} from "../utils/block-process";
-import { handleCurators, updateIsCurrentlyCurator } from "src/modules/handle-curators";
+import { EventsProcessed, EventsQuery } from "src/interfaces/block-chain-service";
+import { updateNetworkParameters } from "src/modules/update-network-params";
+import { Web3Connection } from "@taikai/dappkit";
 
-export const name = "updateNetworkParameters";
+export const name = "UpdateNetworkParameters";
 export const schedule = "0 0 * * *";
 export const description = "update network parameters on database";
 export const author = "Vitor Hugo";
 
-const {NEXT_WALLET_PRIVATE_KEY: privateKey} = process.env;
-
 export async function action(query?: EventsQuery): Promise<EventsProcessed> {
   const eventsProcessed: EventsProcessed = {};
 
   logger.info(`${name} start`);
 
-  const entries = await getChainsRegistryAndNetworks();
-  for (const [web3Host, {chainId: chain_id,}] of entries) {
-    const where = {
-      chain_id,
-      ...query?.networkName ? {name: {[Op.iLike]: query.networkName}} : {},
-    }
-
-    const networks = await db.networks.findAll({
-      where,
-      include: [{ association: "curators", required: false }],
-    });
-
-    try {
-
-      if (!networks || !networks.length) {
-        logger.warn(`${name} found no networks`);
-        return eventsProcessed;
-      }
-
-      const web3Connection = new Web3Connection({web3Host, privateKey});
-      await web3Connection.start();
-
-      for (const network of networks) {
-        try {
-          const networkContract = new Network_v2(web3Connection, network.networkAddress);
-          await networkContract.start();
-          const councilAmount = await networkContract.councilAmount();
-          const needsToUpdateCurators = councilAmount !== network.councilAmount;
-
-          network.councilAmount = councilAmount;
-          network.disputableTime = (await networkContract.disputableTime()) / 1000;
-          network.draftTime = (await networkContract.draftTime()) / 1000;
-          network.oracleExchangeRate = await networkContract.oracleExchangeRate();
-          network.mergeCreatorFeeShare = await networkContract.mergeCreatorFeeShare();
-          network.percentageNeededForDispute = await networkContract.percentageNeededForDispute();
-          network.cancelableTime = (await networkContract.cancelableTime()) / 1000;
-          network.proposerFeeShare = await networkContract.proposerFeeShare();
+  if (!query || !query?.chainId || !query?.address) {
+    logger.info(`${name} missing parameters`);
+    return eventsProcessed;
+  }
 
-          await network.save();
+  const { chainId, address } = query;
 
-          if (needsToUpdateCurators) {
-            await Promise.all(network.curators.map(async (curator) => {
-              const actorVotesResume = await networkContract.getOraclesResume(curator.address);
-              await handleCurators(curator.address, actorVotesResume, councilAmount, network.id);
-            }));
+  const chain = await db.chains.findOne({
+    where: {
+      chainId: +chainId
+    }
+  });
 
-            const currentCurators = await db.curators.findAll({
-              where: {
-                isCurrentlyCurator: true,
-                networkId: network.id
-              }
-            });
+  if (!chain) {
+    logger.info(`${name} invalid chain ${chainId}`);
+    return eventsProcessed;
+  }
 
-            network.councilMembers = currentCurators.map(({ address }) => address);
-            await network.save();
-          }
+  try {
+    const connection = new Web3Connection({
+      web3Host: chain.privateChainRpc,
+      skipWindowAssignment: true,
+    });
+    await connection.start();
 
-          eventsProcessed[network.name!] = ["updated"];
+    await updateNetworkParameters({
+      networkAddress: address,
+      chainId: +chainId,
+      connection
+    });
 
-          logger.info(`${name} parameters saved ${network.name} ${network.networkAddress}`);
-        } catch (error: any) {
-          logger.error(`${name} Failed to save parameters of ${network.name} ${network.networkAddress}`, error?.message || error.toString());
-        }
-      }
-    } catch (err: any) {
-      logger.error(`${name} Error`, err?.message || err.toString());
-    }
+    eventsProcessed[address] = ["updated"];
 
+    logger.info(`${name} parameters saved ${address} ${chainId}`);
+  } catch (error: any) {
+    logger.error(`${name} Failed to save parameters of ${address} ${chainId}`, error?.message || error.toString());
   }
 
   return eventsProcessed;

src/actions/update-network-parameters.ts

@@ -17,7 +17,8 @@ import {action as OraclesTransfer} from "../actions/get-oracles-transfer-events"
 import {action as UpdateBountiesToDraft} from "../actions/update-bounties-to-draft";
 import {action as DeletePendingNetworks} from "../actions/delete-pending-networks";
 import {action as DeletePendingBounties} from "../actions/delete-pending-bounties";
-import {action as UpdateNetworkParams} from "../actions/update-network-parameters";
+import {action as NetworkParamChanged} from "../actions/get-network-param-changed";
+import {action as UpdateNetworkParameters} from "../actions/update-network-parameters";
 import {action as BountyWithdrawReward} from "../actions/get-bounty-reward-withdraw";
 import {action as UpdateHeaders} from "../actions/get-prices-header-information";
 import {action as GenerateNftImage} from "../actions/generate-nft-images";
@@ -45,7 +46,7 @@ export const REGISTRY_EVENTS = {
 export const NETWORK_EVENTS = {
   BountyCreated, BountyCanceled, BountyFunded, BountyClosed, BountyPullRequestCreated, BountyPullRequestReadyForReview,
   BountyPullRequestCanceled, BountyProposalCreated, BountyProposalDisputed, BountyProposalRefused, BountyAmountUpdated,
-  OraclesChanged, OraclesTransfer,
+  OraclesChanged, OraclesTransfer, NetworkParamChanged,
 }
 
 /**
@@ -57,10 +58,10 @@ export const MIDNIGHT_ACTIONS = {
   UpdateBountiesToDraft,
   DeletePendingNetworks,
   DeletePendingBounties,
-  UpdateNetworkParams,
   SaveLockedTokensEvents,
   SaveDelegatedTokensEvents,
   CalculateUserPoints,
+  UpdateNetworkParameters,
 }
 
 export const MINUTE_ACTIONS = {

src/modules/chain-events.ts

@@ -0,0 +1,60 @@
+import { Network_v2, Web3Connection } from "@taikai/dappkit";
+
+import db from "src/db";
+import { handleCurators } from "src/modules/handle-curators";
+
+type UpdateNetworkParametersProps = {
+  networkAddress: string,
+  chainId: number,
+  connection: Web3Connection,
+}
+export async function updateNetworkParameters({
+  networkAddress,
+  chainId,
+  connection
+}: UpdateNetworkParametersProps) {
+  const networkOnDb = await db.networks.findOne({
+    where: {
+      networkAddress: networkAddress,
+      chain_id: chainId
+    },
+    include: [{ association: "curators", required: false }],
+  });
+
+  if (!networkOnDb) {
+    throw new Error(`Network with address ${networkAddress} not found for chain ${chainId}`);
+  }
+
+  const networkContract = new Network_v2(connection, networkOnDb.networkAddress);
+  await networkContract.start();
+  const councilAmount = await networkContract.councilAmount();
+  const needsToUpdateCurators = councilAmount !== networkOnDb.councilAmount;
+
+  networkOnDb.councilAmount = councilAmount;
+  networkOnDb.disputableTime = (await networkContract.disputableTime()) / 1000;
+  networkOnDb.draftTime = (await networkContract.draftTime()) / 1000;
+  networkOnDb.oracleExchangeRate = await networkContract.oracleExchangeRate();
+  networkOnDb.mergeCreatorFeeShare = await networkContract.mergeCreatorFeeShare();
+  networkOnDb.percentageNeededForDispute = await networkContract.percentageNeededForDispute();
+  networkOnDb.cancelableTime = (await networkContract.cancelableTime()) / 1000;
+  networkOnDb.proposerFeeShare = await networkContract.proposerFeeShare();
+
+  await networkOnDb.save();
+
+  if (needsToUpdateCurators) {
+    await Promise.all(networkOnDb.curators.map(async (curator) => {
+      const actorVotesResume = await networkContract.getOraclesResume(curator.address);
+      await handleCurators(curator.address, actorVotesResume, councilAmount, networkOnDb.id);
+    }));
+
+    const currentCurators = await db.curators.findAll({
+      where: {
+        isCurrentlyCurator: true,
+        networkId: networkOnDb.id
+      }
+    });
+
+    networkOnDb.councilMembers = currentCurators.map(({ address }) => address);
+    await networkOnDb.save();
+  }
+}