@gearbox-protocol/sdk 3.0.0-vfour.340 → 3.0.0-vfour.341

package/dist/cjs/sdk/market/pricefeeds/RedstoneUpdater.js

@@ -27,6 +27,8 @@ var import_protocol = require("@redstone-finance/protocol");
 var import_viem = require("viem");
 var import_base = require("../../base/index.js");
 var import_utils = require("../../utils/index.js");
+const MAX_DATA_TIMESTAMP_DELAY_SECONDS = 10n * 60n;
+const MAX_DATA_TIMESTAMP_AHEAD_SECONDS = 60n;
 class RedstoneUpdateTx {
   raw;
   data;
@@ -38,6 +40,17 @@ class RedstoneUpdateTx {
     const cached = this.data.cached ? " (cached)" : "";
     return `redstone feed ${this.data.dataFeedId} at ${this.data.priceFeed} with timestamp ${this.data.timestamp}${cached}`;
   }
+  validateTimestamp(blockTimestamp) {
+    const { timestamp: expectedPayloadTimestamp } = this.data;
+    if (blockTimestamp < expectedPayloadTimestamp) {
+      if (BigInt(expectedPayloadTimestamp) - blockTimestamp > MAX_DATA_TIMESTAMP_AHEAD_SECONDS) {
+        return "in future";
+      }
+    } else if (blockTimestamp - BigInt(expectedPayloadTimestamp) > MAX_DATA_TIMESTAMP_DELAY_SECONDS) {
+      return "too old";
+    }
+    return "valid";
+  }
 }
 class RedstoneUpdater extends import_base.SDKConstruct {
   #logger;

package/dist/cjs/sdk/utils/viem/simulateWithPriceUpdates.js

@@ -19,39 +19,65 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var simulateWithPriceUpdates_exports = {};
 __export(simulateWithPriceUpdates_exports, {
   SimulateWithPriceUpdatesError: () => SimulateWithPriceUpdatesError,
+  getSimulateWithPriceUpdatesError: () => getSimulateWithPriceUpdatesError,
   simulateWithPriceUpdates: () => simulateWithPriceUpdates
 });
 module.exports = __toCommonJS(simulateWithPriceUpdates_exports);
 var import_viem = require("viem");
 var import_abi = require("../../../abi/index.js");
-var import_hex = require("../hex.js");
 var import_simulateMulticall = require("./simulateMulticall.js");
+const multicallTimestampAbi = (0, import_viem.parseAbi)([
+  "function getCurrentBlockTimestamp() public view returns (uint256 timestamp)"
+]);
 const updatePriceFeedAbi = [...import_abi.iUpdatablePriceFeedAbi, ...import_abi.errorAbis];
 async function simulateWithPriceUpdates(client, parameters) {
   const { contracts: restContracts, priceUpdates, ...rest } = parameters;
   if (restContracts.length === 0) {
-    throw new SimulateWithPriceUpdatesError(
+    throw getSimulateWithPriceUpdatesError(
       new import_viem.BaseError("no contracts calls provided"),
       priceUpdates,
       restContracts
     );
   }
+  const multicallAddress = rest.multicallAddress ?? client?.chain?.contracts?.multicall3?.address;
+  if (!multicallAddress) {
+    throw new Error(
+      "client chain not configured. multicallAddress is required."
+    );
+  }
   try {
     const contracts = [
+      {
+        abi: multicallTimestampAbi,
+        address: multicallAddress,
+        functionName: "getCurrentBlockTimestamp",
+        args: []
+      },
       ...priceUpdates.map(rawTxToMulticallPriceUpdate),
       ...restContracts
     ];
     const resp = await (0, import_simulateMulticall.simulateMulticall)(client, {
       contracts,
       ...rest,
-      allowFailure: false,
+      allowFailure: true,
       batchSize: 0
       // we cannot have price updates and compressor request in different batches
     });
-    const restResults = resp.slice(priceUpdates.length);
+    if (resp.some((r) => r.status === "failure")) {
+      throw getSimulateWithPriceUpdatesError(
+        void 0,
+        priceUpdates,
+        restContracts,
+        resp
+      );
+    }
+    const restResults = resp.slice(priceUpdates.length + 1).map((r) => r.result);
     return restResults;
   } catch (e) {
-    throw new SimulateWithPriceUpdatesError(
+    if (e instanceof SimulateWithPriceUpdatesError) {
+      throw e;
+    }
+    throw getSimulateWithPriceUpdatesError(
       e,
       priceUpdates,
       restContracts
@@ -78,57 +104,73 @@ function rawTxToMulticallPriceUpdate({
     args
   };
 }
+function getSimulateWithPriceUpdatesError(cause, priceUpdates, calls, results) {
+  if (!results) {
+    return new SimulateWithPriceUpdatesError(cause, {
+      priceUpdates: priceUpdates.map((p) => p.pretty),
+      calls: calls.map((c) => `${c.address}.${c.functionName}`)
+    });
+  }
+  const timestamp = results[0]?.result;
+  const priceUpdatesResults = results.slice(1, 1 + priceUpdates.length);
+  const callsResults = results.slice(1 + priceUpdates.length);
+  const prettyPriceUpdates = priceUpdates.map((p, i) => {
+    const result = priceUpdatesResults[i];
+    let tsValid = timestamp ? p.validateTimestamp(timestamp) : "";
+    tsValid = tsValid === "valid" ? "" : `[timestamp ${tsValid}]`;
+    return [extractCallError(result), p.pretty, tsValid].filter(Boolean).join(" ");
+  });
+  const prettyCalls = callsResults.map((c, i) => {
+    const call = calls[i];
+    return [extractCallError(c), `${call.address}.${call.functionName}`].filter(Boolean).join(" ");
+  });
+  return new SimulateWithPriceUpdatesError(cause, {
+    timestamp,
+    priceUpdates: prettyPriceUpdates,
+    calls: prettyCalls
+  });
+}
+function extractCallError(result) {
+  if (result.status === "success") {
+    return "";
+  }
+  const err = result.error;
+  const error = err instanceof import_viem.BaseError ? err.walk((e) => e instanceof import_viem.ContractFunctionRevertedError) : void 0;
+  if (error instanceof import_viem.ContractFunctionRevertedError) {
+    return "[" + (error.data?.errorName ?? "reverted") + "]";
+  }
+  return err instanceof import_viem.BaseError ? `[${err.name}]` : "[error]";
+}
 class SimulateWithPriceUpdatesError extends import_viem.BaseError {
   cause;
-  priceUpdates;
-  calls;
-  constructor(cause, priceUpdates, calls) {
-    let failedPriceFeed = "0x0";
+  timestamp;
+  constructor(cause, params) {
+    const { calls, priceUpdates, timestamp } = params;
     const base = cause instanceof import_viem.BaseError ? cause : {};
     let causeMeta = base.metaMessages ? [...base.metaMessages, " "] : [];
-    if (base instanceof import_viem.ContractFunctionExecutionError && base.functionName === "updatePrice") {
-      failedPriceFeed = base.contractAddress ?? "0x0";
-      causeMeta = [
-        `simulate multicall with ${priceUpdates.length} price updates failed`,
-        " "
-      ];
-      const updateRevert = cause instanceof import_viem.BaseError ? cause.walk(
-        (err) => err instanceof import_viem.ContractFunctionRevertedError
-      ) : void 0;
-      if (updateRevert) {
-        causeMeta = [
-          `simulate multicall with ${priceUpdates.length} price updates failed: ${updateRevert.metaMessages?.[0]}`,
-          " "
-        ];
-      }
-    }
-    const priceUpdatesMeta = [
-      "Price Updates:",
-      ...priceUpdates.map(
-        (u) => `${(0, import_hex.hexEq)(u.data.priceFeed, failedPriceFeed) ? "[FAILED] " : ""}${u.pretty}`
-      )
-    ];
-    const callsMeta = [
-      "Calls:",
-      ...calls.map((c) => `${c.address}.${c.functionName}`)
-    ];
     super(
       `simulate multicall with ${priceUpdates.length} price updates failed`,
       {
         cause: base,
-        metaMessages: [...causeMeta, ...priceUpdatesMeta, ...callsMeta].filter(
-          Boolean
-        ),
+        metaMessages: [
+          ...causeMeta,
+          ...timestamp ? [" ", "Block Timestamp: " + timestamp.toString(), " "] : [],
+          "Price Updates:",
+          ...priceUpdates,
+          " ",
+          "Calls: ",
+          ...calls
+        ].filter(Boolean),
         name: "SimulateWithPriceUpdatesError"
       }
     );
     this.cause = cause;
-    this.priceUpdates = priceUpdates;
-    this.calls = calls;
+    this.timestamp = timestamp;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SimulateWithPriceUpdatesError,
+  getSimulateWithPriceUpdatesError,
   simulateWithPriceUpdates
 });

package/dist/esm/sdk/market/pricefeeds/RedstoneUpdater.js

@@ -3,6 +3,8 @@ import { RedstonePayload } from "@redstone-finance/protocol";
 import { encodeAbiParameters, toBytes } from "viem";
 import { SDKConstruct } from "../../base/index.js";
 import { childLogger, retry } from "../../utils/index.js";
+const MAX_DATA_TIMESTAMP_DELAY_SECONDS = 10n * 60n;
+const MAX_DATA_TIMESTAMP_AHEAD_SECONDS = 60n;
 class RedstoneUpdateTx {
   raw;
   data;
@@ -14,6 +16,17 @@ class RedstoneUpdateTx {
     const cached = this.data.cached ? " (cached)" : "";
     return `redstone feed ${this.data.dataFeedId} at ${this.data.priceFeed} with timestamp ${this.data.timestamp}${cached}`;
   }
+  validateTimestamp(blockTimestamp) {
+    const { timestamp: expectedPayloadTimestamp } = this.data;
+    if (blockTimestamp < expectedPayloadTimestamp) {
+      if (BigInt(expectedPayloadTimestamp) - blockTimestamp > MAX_DATA_TIMESTAMP_AHEAD_SECONDS) {
+        return "in future";
+      }
+    } else if (blockTimestamp - BigInt(expectedPayloadTimestamp) > MAX_DATA_TIMESTAMP_DELAY_SECONDS) {
+      return "too old";
+    }
+    return "valid";
+  }
 }
 class RedstoneUpdater extends SDKConstruct {
   #logger;

package/dist/esm/sdk/utils/viem/simulateWithPriceUpdates.js

@@ -1,38 +1,63 @@
 import {
   BaseError,
-  ContractFunctionExecutionError,
   ContractFunctionRevertedError,
-  decodeFunctionData
+  decodeFunctionData,
+  parseAbi
 } from "viem";
 import { errorAbis, iUpdatablePriceFeedAbi } from "../../../abi/index.js";
-import { hexEq } from "../hex.js";
 import { simulateMulticall } from "./simulateMulticall.js";
+const multicallTimestampAbi = parseAbi([
+  "function getCurrentBlockTimestamp() public view returns (uint256 timestamp)"
+]);
 const updatePriceFeedAbi = [...iUpdatablePriceFeedAbi, ...errorAbis];
 async function simulateWithPriceUpdates(client, parameters) {
   const { contracts: restContracts, priceUpdates, ...rest } = parameters;
   if (restContracts.length === 0) {
-    throw new SimulateWithPriceUpdatesError(
+    throw getSimulateWithPriceUpdatesError(
       new BaseError("no contracts calls provided"),
       priceUpdates,
       restContracts
     );
   }
+  const multicallAddress = rest.multicallAddress ?? client?.chain?.contracts?.multicall3?.address;
+  if (!multicallAddress) {
+    throw new Error(
+      "client chain not configured. multicallAddress is required."
+    );
+  }
   try {
     const contracts = [
+      {
+        abi: multicallTimestampAbi,
+        address: multicallAddress,
+        functionName: "getCurrentBlockTimestamp",
+        args: []
+      },
       ...priceUpdates.map(rawTxToMulticallPriceUpdate),
       ...restContracts
     ];
     const resp = await simulateMulticall(client, {
       contracts,
       ...rest,
-      allowFailure: false,
+      allowFailure: true,
       batchSize: 0
       // we cannot have price updates and compressor request in different batches
     });
-    const restResults = resp.slice(priceUpdates.length);
+    if (resp.some((r) => r.status === "failure")) {
+      throw getSimulateWithPriceUpdatesError(
+        void 0,
+        priceUpdates,
+        restContracts,
+        resp
+      );
+    }
+    const restResults = resp.slice(priceUpdates.length + 1).map((r) => r.result);
     return restResults;
   } catch (e) {
-    throw new SimulateWithPriceUpdatesError(
+    if (e instanceof SimulateWithPriceUpdatesError) {
+      throw e;
+    }
+    throw getSimulateWithPriceUpdatesError(
       e,
       priceUpdates,
       restContracts
@@ -59,56 +84,72 @@ function rawTxToMulticallPriceUpdate({
     args
   };
 }
+function getSimulateWithPriceUpdatesError(cause, priceUpdates, calls, results) {
+  if (!results) {
+    return new SimulateWithPriceUpdatesError(cause, {
+      priceUpdates: priceUpdates.map((p) => p.pretty),
+      calls: calls.map((c) => `${c.address}.${c.functionName}`)
+    });
+  }
+  const timestamp = results[0]?.result;
+  const priceUpdatesResults = results.slice(1, 1 + priceUpdates.length);
+  const callsResults = results.slice(1 + priceUpdates.length);
+  const prettyPriceUpdates = priceUpdates.map((p, i) => {
+    const result = priceUpdatesResults[i];
+    let tsValid = timestamp ? p.validateTimestamp(timestamp) : "";
+    tsValid = tsValid === "valid" ? "" : `[timestamp ${tsValid}]`;
+    return [extractCallError(result), p.pretty, tsValid].filter(Boolean).join(" ");
+  });
+  const prettyCalls = callsResults.map((c, i) => {
+    const call = calls[i];
+    return [extractCallError(c), `${call.address}.${call.functionName}`].filter(Boolean).join(" ");
+  });
+  return new SimulateWithPriceUpdatesError(cause, {
+    timestamp,
+    priceUpdates: prettyPriceUpdates,
+    calls: prettyCalls
+  });
+}
+function extractCallError(result) {
+  if (result.status === "success") {
+    return "";
+  }
+  const err = result.error;
+  const error = err instanceof BaseError ? err.walk((e) => e instanceof ContractFunctionRevertedError) : void 0;
+  if (error instanceof ContractFunctionRevertedError) {
+    return "[" + (error.data?.errorName ?? "reverted") + "]";
+  }
+  return err instanceof BaseError ? `[${err.name}]` : "[error]";
+}
 class SimulateWithPriceUpdatesError extends BaseError {
   cause;
-  priceUpdates;
-  calls;
-  constructor(cause, priceUpdates, calls) {
-    let failedPriceFeed = "0x0";
+  timestamp;
+  constructor(cause, params) {
+    const { calls, priceUpdates, timestamp } = params;
     const base = cause instanceof BaseError ? cause : {};
     let causeMeta = base.metaMessages ? [...base.metaMessages, " "] : [];
-    if (base instanceof ContractFunctionExecutionError && base.functionName === "updatePrice") {
-      failedPriceFeed = base.contractAddress ?? "0x0";
-      causeMeta = [
-        `simulate multicall with ${priceUpdates.length} price updates failed`,
-        " "
-      ];
-      const updateRevert = cause instanceof BaseError ? cause.walk(
-        (err) => err instanceof ContractFunctionRevertedError
-      ) : void 0;
-      if (updateRevert) {
-        causeMeta = [
-          `simulate multicall with ${priceUpdates.length} price updates failed: ${updateRevert.metaMessages?.[0]}`,
-          " "
-        ];
-      }
-    }
-    const priceUpdatesMeta = [
-      "Price Updates:",
-      ...priceUpdates.map(
-        (u) => `${hexEq(u.data.priceFeed, failedPriceFeed) ? "[FAILED] " : ""}${u.pretty}`
-      )
-    ];
-    const callsMeta = [
-      "Calls:",
-      ...calls.map((c) => `${c.address}.${c.functionName}`)
-    ];
     super(
       `simulate multicall with ${priceUpdates.length} price updates failed`,
       {
         cause: base,
-        metaMessages: [...causeMeta, ...priceUpdatesMeta, ...callsMeta].filter(
-          Boolean
-        ),
+        metaMessages: [
+          ...causeMeta,
+          ...timestamp ? [" ", "Block Timestamp: " + timestamp.toString(), " "] : [],
+          "Price Updates:",
+          ...priceUpdates,
+          " ",
+          "Calls: ",
+          ...calls
+        ].filter(Boolean),
         name: "SimulateWithPriceUpdatesError"
       }
     );
     this.cause = cause;
-    this.priceUpdates = priceUpdates;
-    this.calls = calls;
+    this.timestamp = timestamp;
   }
 }
 export {
   SimulateWithPriceUpdatesError,
+  getSimulateWithPriceUpdatesError,
   simulateWithPriceUpdates
 };

package/dist/types/sdk/market/pricefeeds/RedstoneUpdater.d.ts

@@ -15,6 +15,7 @@ export declare class RedstoneUpdateTx implements IPriceUpdateTx<RedstoneUpdateTa
     readonly data: RedstoneUpdateTask;
     constructor(raw: RawTx, data: RedstoneUpdateTask);
     get pretty(): string;
+    validateTimestamp(blockTimestamp: bigint): "valid" | "too old" | "in future";
 }
 /**
  * Class to update multiple redstone price feeds at once

package/dist/types/sdk/types/transactions.d.ts

@@ -26,6 +26,7 @@ export interface IPriceUpdateTx<Data extends {
     raw: RawTx;
     data: Data;
     pretty: string;
+    validateTimestamp: (timestamp: bigint) => "valid" | "too old" | "in future";
 }
 export interface MultiCall {
     target: Address;

package/dist/types/sdk/utils/viem/simulateWithPriceUpdates.d.ts

@@ -17,12 +17,17 @@ export type SimulateWithPriceUpdatesReturnType<contracts extends readonly unknow
     error: Error;
 }> = MulticallReturnType<contracts, false, options>;
 export declare function simulateWithPriceUpdates<const contracts extends readonly unknown[], chain extends Chain | undefined>(client: Client<Transport, chain>, parameters: SimulateWithPriceUpdatesParameters<contracts>): Promise<SimulateWithPriceUpdatesReturnType<contracts>>;
-export type SimulateWithPriceUpdatesErrorType<contracts extends readonly unknown[]> = SimulateWithPriceUpdatesError<contracts> & {
+export declare function getSimulateWithPriceUpdatesError<contracts extends readonly unknown[]>(cause: Error | undefined, priceUpdates: IPriceUpdateTx[], calls: MulticallContracts<Narrow<contracts>>, results?: MulticallReturnType<Narrow<contracts>>): SimulateWithPriceUpdatesError;
+export type SimulateWithPriceUpdatesErrorType = SimulateWithPriceUpdatesError & {
     name: "SimulateWithPriceUpdatesError";
 };
-export declare class SimulateWithPriceUpdatesError<contracts extends readonly unknown[]> extends BaseError {
-    cause: Error;
-    readonly priceUpdates: IPriceUpdateTx[];
-    readonly calls: MulticallContracts<Narrow<contracts>>;
-    constructor(cause: Error, priceUpdates: IPriceUpdateTx[], calls: MulticallContracts<Narrow<contracts>>);
+export interface SimulateWithPriceUpdatesErrorParams {
+    timestamp?: bigint;
+    priceUpdates: string[];
+    calls: string[];
+}
+export declare class SimulateWithPriceUpdatesError extends BaseError {
+    cause?: Error;
+    readonly timestamp?: bigint;
+    constructor(cause: Error | undefined, params: SimulateWithPriceUpdatesErrorParams);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "3.0.0-vfour.340",
+  "version": "3.0.0-vfour.341",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",