Abehjati/use-update-if-needed (#36)

* Update price pusher to use updateIfNecessary
* Update pusher
* improve logs
* Update solidity sdk to 0.5.2

Author: ali-behjati

pyth-evm-price-pusher/package-lock.json

@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@pythnetwork/pyth-evm-js": "^0.5.0",
-    "@pythnetwork/pyth-sdk-solidity": "^0.4.0",
+    "@pythnetwork/pyth-sdk-solidity": "^0.5.2",
     "@truffle/hdwallet-provider": "^2.0.8",
     "joi": "^17.6.0",
     "web3": "^1.5.3",

pyth-evm-price-pusher/package.json

@@ -1,17 +1,21 @@
-import { EvmPriceServiceConnection } from "@pythnetwork/pyth-evm-js";
-import { DurationInSeconds, sleep } from "./utils";
-import { PriceListener } from "./price-listener";
+import {
+  EvmPriceServiceConnection,
+  UnixTimestamp,
+} from "@pythnetwork/pyth-evm-js";
+import { addLeading0x, DurationInSeconds, sleep } from "./utils";
+import { PriceInfo, PriceListener } from "./price-listener";
 import { Contract } from "web3-eth-contract";
 import AbstractPythAbi from "@pythnetwork/pyth-sdk-solidity/abis/AbstractPyth.json";
 import Web3 from "web3";
 import HDWalletProvider from "@truffle/hdwallet-provider";
 import { PriceConfig } from "./price-config";
+import { TransactionReceipt } from "ethereum-protocol";
 
 export class Pusher {
   private connection: EvmPriceServiceConnection;
   private pythContract: Contract;
   private targetPriceListener: PriceListener;
-  private srcPriceListener: PriceListener;
+  private sourcePriceListener: PriceListener;
   private priceConfigs: PriceConfig[];
 
   private cooldownDuration: DurationInSeconds;
@@ -22,15 +26,15 @@ export class Pusher {
     mnemonic: string,
     pythContractAddr: string,
     targetPriceListener: PriceListener,
-    srcPriceListener: PriceListener,
+    sourcePriceListener: PriceListener,
     priceConfigs: PriceConfig[],
     config: {
       cooldownDuration: DurationInSeconds;
     }
   ) {
     this.connection = connection;
     this.targetPriceListener = targetPriceListener;
-    this.srcPriceListener = srcPriceListener;
+    this.sourcePriceListener = sourcePriceListener;
     this.priceConfigs = priceConfigs;
 
     this.cooldownDuration = config.cooldownDuration;
@@ -55,21 +59,46 @@ export class Pusher {
 
   async start() {
     for (;;) {
-      const pricesToPush = this.priceConfigs.filter(
-        this.shouldUpdate.bind(this)
-      );
-      this.pushUpdates(pricesToPush);
+      const pricesToPush: PriceConfig[] = [];
+      const pubTimesToPush: UnixTimestamp[] = [];
+
+      for (const priceConfig of this.priceConfigs) {
+        const priceId = priceConfig.id;
+
+        const targetLatestPrice =
+          this.targetPriceListener.getLatestPriceInfo(priceId);
+        const sourceLatestPrice =
+          this.sourcePriceListener.getLatestPriceInfo(priceId);
+
+        if (
+          this.shouldUpdate(priceConfig, sourceLatestPrice, targetLatestPrice)
+        ) {
+          pricesToPush.push(priceConfig);
+          pubTimesToPush.push((targetLatestPrice?.publishTime || 0) + 1);
+        }
+      }
+      this.pushUpdates(pricesToPush, pubTimesToPush);
       await sleep(this.cooldownDuration * 1000);
     }
   }
 
-  async pushUpdates(pricesToPush: PriceConfig[]) {
+  // The pubTimes are passed here to use the values that triggered the push.
+  // This is an optimization to avoid getting a newer value (as an update comes)
+  // and will help multiple price pushers to have consistent behaviour.
+  async pushUpdates(
+    pricesToPush: PriceConfig[],
+    pubTimesToPush: UnixTimestamp[]
+  ) {
     if (pricesToPush.length === 0) {
       return;
     }
 
+    const priceIds = pricesToPush.map((priceConfig) =>
+      addLeading0x(priceConfig.id)
+    );
+
     const priceFeedUpdateData = await this.connection.getPriceFeedsUpdateData(
-      pricesToPush.map((priceConfig) => priceConfig.id)
+      priceIds
     );
 
     console.log(
@@ -80,10 +109,44 @@ export class Pusher {
     );
 
     this.pythContract.methods
-      .updatePriceFeeds(priceFeedUpdateData)
+      .updatePriceFeedsIfNecessary(
+        priceFeedUpdateData,
+        priceIds,
+        pubTimesToPush
+      )
       .send()
       .on("transactionHash", (hash: string) => {
-        console.log(`Tx hash: ${hash}`);
+        console.log(`Successful. Tx hash: ${hash}`);
+      })
+      .on("error", (err: Error, receipt: TransactionReceipt) => {
+        if (
+          err.message.includes(
+            "no prices in the submitted batch have fresh prices, so this update will have no effect"
+          )
+        ) {
+          console.log(
+            "The target chain price has already updated, Skipping this push."
+          );
+          return;
+        }
+
+        if (err.message.includes("the tx doesn't have the correct nonce.")) {
+          console.log(
+            "Multiple users are using the same accounts and nonce is incorrect. Skipping this push."
+          );
+          return;
+        }
+
+        if (
+          err.message.includes("sender doesn't have enough funds to send tx.")
+        ) {
+          console.error("Payer is out of balance, please top it up.");
+          throw err;
+        }
+
+        console.error("An unidentified error has occured:");
+        console.error(err, receipt);
+        console.error("Skipping this push.");
       });
   }
 
@@ -93,15 +156,15 @@ export class Pusher {
    * @param priceConfig Config of the price feed to check
    * @returns True if the on-chain price needs to be updated.
    */
-  shouldUpdate(priceConfig: PriceConfig): boolean {
+  shouldUpdate(
+    priceConfig: PriceConfig,
+    sourceLatestPrice: PriceInfo | undefined,
+    targetLatestPrice: PriceInfo | undefined
+  ): boolean {
     const priceId = priceConfig.id;
 
-    const targetLatestPrice =
-      this.targetPriceListener.getLatestPriceInfo(priceId);
-    const srcLatestPrice = this.srcPriceListener.getLatestPriceInfo(priceId);
-
     // There is no price to update the target with.
-    if (srcLatestPrice === undefined) {
+    if (sourceLatestPrice === undefined) {
       return false;
     }
 
@@ -114,21 +177,21 @@ export class Pusher {
     }
 
     // The current price is not newer than the price onchain
-    if (srcLatestPrice.publishTime < targetLatestPrice.publishTime) {
+    if (sourceLatestPrice.publishTime < targetLatestPrice.publishTime) {
       return false;
     }
 
     const timeDifference =
-      srcLatestPrice.publishTime - targetLatestPrice.publishTime;
+      sourceLatestPrice.publishTime - targetLatestPrice.publishTime;
 
     const priceDeviationPct =
       (Math.abs(
-        Number(srcLatestPrice.price) - Number(targetLatestPrice.price)
+        Number(sourceLatestPrice.price) - Number(targetLatestPrice.price)
       ) /
         Number(targetLatestPrice.price)) *
       100;
     const confidenceRatioPct = Math.abs(
-      (Number(srcLatestPrice.conf) / Number(srcLatestPrice.price)) * 100
+      (Number(sourceLatestPrice.conf) / Number(sourceLatestPrice.price)) * 100
     );
 
     console.log(`Analyzing price ${priceConfig.alias} (${priceId})`);