Optimizes for read on NormalizedApi3ReaderProxyV1 and ScaledApi3FeedProxyV1 while scaling feeds

Author: acenolaza

contracts/NormalizedApi3ReaderProxyV1.sol

@@ -15,24 +15,35 @@ contract NormalizedApi3ReaderProxyV1 is INormalizedApi3ReaderProxyV1 {
     /// @notice Chainlink AggregatorV2V3Interface contract address
     address public immutable override feed;
 
-    uint8 internal immutable feedDecimals;
+    /// @dev Pre-calculated factor for scaling to 18 decimals.
+    int256 private immutable scalingFactor;
+
+    /// @dev True for upscaling (multiply by scalingFactor), else downscaling
+    /// (divide by scalingFactor).
+    bool private immutable isUpscaling;
 
     /// @param feed_ The address of the Chainlink AggregatorV2V3Interface feed
     constructor(address feed_) {
         if (feed_ == address(0)) {
             revert ZeroProxyAddress();
         }
-
         uint8 feedDecimals_ = AggregatorV2V3Interface(feed_).decimals();
         if (feedDecimals_ == 0 || feedDecimals_ > 36) {
             revert UnsupportedFeedDecimals();
         }
+        if (feedDecimals_ == 18) {
+            revert NoNormalizationNeeded();
+        }
         feed = feed_;
-        feedDecimals = feedDecimals_;
+        uint8 delta = feedDecimals_ > 18
+            ? feedDecimals_ - 18
+            : 18 - feedDecimals_;
+        scalingFactor = int256(10 ** uint256(delta));
+        isUpscaling = feedDecimals_ < 18;
     }
 
     /// @notice Returns the price of the underlying Chainlink feed normalized to
-    /// 18 decimals
+    /// 18 decimals.
     /// @return value The normalized signed fixed-point value with 18 decimals
     /// @return timestamp The updatedAt timestamp of the feed
     function read()
@@ -44,15 +55,9 @@ contract NormalizedApi3ReaderProxyV1 is INormalizedApi3ReaderProxyV1 {
         (, int256 answer, , uint256 updatedAt, ) = AggregatorV2V3Interface(feed)
             .latestRoundData();
 
-        if (feedDecimals != 18) {
-            uint8 delta = feedDecimals > 18
-                ? feedDecimals - 18
-                : 18 - feedDecimals;
-            int256 factor = int256(10 ** uint256(delta));
-            answer = feedDecimals < 18 ? answer * factor : answer / factor;
-        }
-
-        value = int224(answer);
+        value = isUpscaling
+            ? int224(answer * scalingFactor)
+            : int224(answer / scalingFactor);
         timestamp = uint32(updatedAt);
     }
 

contracts/adapters/ScaledApi3FeedProxyV1.sol

@@ -13,8 +13,16 @@ contract ScaledApi3FeedProxyV1 is IScaledApi3FeedProxyV1 {
     /// @notice IApi3ReaderProxy contract address
     address public immutable override proxy;
 
+    /// @dev Target decimals for the scaled value.
     uint8 private immutable targetDecimals;
 
+    /// @dev Pre-calculated factor for scaling from 18 decimals.
+    int256 private immutable scalingFactor;
+
+    /// @dev True for upscaling (multiply by scalingFactor), else downscaling
+    /// (divide by scalingFactor).
+    bool private immutable isUpscaling;
+
     /// @param proxy_ IApi3ReaderProxy contract address
     /// @param targetDecimals_ Decimals used to scale the IApi3ReaderProxy value
     constructor(address proxy_, uint8 targetDecimals_) {
@@ -24,9 +32,16 @@ contract ScaledApi3FeedProxyV1 is IScaledApi3FeedProxyV1 {
         if (targetDecimals_ == 0 || targetDecimals_ > 36) {
             revert InvalidDecimals();
         }
-
+        if (targetDecimals_ == 18) {
+            revert NoScalingNeeded();
+        }
         proxy = proxy_;
         targetDecimals = targetDecimals_;
+        uint8 delta = targetDecimals_ > 18
+            ? targetDecimals_ - 18
+            : 18 - targetDecimals_;
+        scalingFactor = int256(10 ** uint256(delta));
+        isUpscaling = targetDecimals_ > 18;
     }
 
     /// @dev AggregatorV2V3Interface users are already responsible with
@@ -124,22 +139,16 @@ contract ScaledApi3FeedProxyV1 is IScaledApi3FeedProxyV1 {
     /// performed using `int256` types. This allows the scaled result to exceed
     /// the `int224` range, provided it fits within `int256`.
     /// Arithmetic operations will revert on overflow or underflow
-    /// (e.g., if `value * factor` exceeds `type(int256).max`).
+    /// (e.g., if `value * scalingFactor` exceeds `type(int256).max`).
     /// @return value The scaled signed fixed-point value with `targetDecimals`.
     /// @return timestamp The timestamp from the underlying proxy.
     function _read() internal view returns (int256 value, uint32 timestamp) {
         (int224 proxyValue, uint32 proxyTimestamp) = IApi3ReaderProxy(proxy)
             .read();
 
-        value = proxyValue;
+        value = isUpscaling
+            ? proxyValue * scalingFactor
+            : proxyValue / scalingFactor;
         timestamp = proxyTimestamp;
-
-        if (18 != targetDecimals) {
-            uint8 delta = 18 > targetDecimals
-                ? 18 - targetDecimals
-                : targetDecimals - 18;
-            int256 factor = int256(10 ** uint256(delta));
-            value = 18 < targetDecimals ? value * factor : value / factor;
-        }
     }
 }

contracts/adapters/interfaces/IScaledApi3FeedProxyV1.sol

@@ -8,6 +8,8 @@ interface IScaledApi3FeedProxyV1 is AggregatorV2V3Interface {
 
     error InvalidDecimals();
 
+    error NoScalingNeeded();
+
     error FunctionIsNotSupported();
 
     function proxy() external view returns (address proxy);

contracts/interfaces/INormalizedApi3ReaderProxyV1.sol

@@ -12,6 +12,8 @@ interface INormalizedApi3ReaderProxyV1 is
 
     error UnsupportedFeedDecimals();
 
+    error NoNormalizationNeeded();
+
     error FunctionIsNotSupported();
 
     function feed() external view returns (address feed);

test/NormalizedApi3ReaderProxyV1.sol.ts

@@ -42,9 +42,24 @@ describe('NormalizedApi3ReaderProxyV1', function () {
 
   describe('constructor', function () {
     context('feed is not zero address', function () {
-      it('constructs', async function () {
-        const { feed, normalizedApi3ReaderProxyV1 } = await helpers.loadFixture(deploy);
-        expect(await normalizedApi3ReaderProxyV1.feed()).to.equal(await feed.getAddress());
+      context('feed does not have 18 decimals', function () {
+        it('constructs', async function () {
+          const { feed, normalizedApi3ReaderProxyV1 } = await helpers.loadFixture(deploy);
+          expect(await normalizedApi3ReaderProxyV1.feed()).to.equal(await feed.getAddress());
+        });
+      });
+      context('feed has 18 decimals', function () {
+        it('reverts', async function () {
+          const { roles, mockAggregatorV2V3Factory } = await helpers.loadFixture(deploy);
+          const feed = await mockAggregatorV2V3Factory.deploy(18, ethers.parseEther('1'), await helpers.time.latest());
+          const normalizedApi3ReaderProxyV1Factory = await ethers.getContractFactory(
+            'NormalizedApi3ReaderProxyV1',
+            roles.deployer
+          );
+          await expect(normalizedApi3ReaderProxyV1Factory.deploy(feed))
+            .to.be.revertedWithCustomError(normalizedApi3ReaderProxyV1Factory, 'NoNormalizationNeeded')
+            .withArgs();
+        });
       });
     });
     context('feed is zero address', function () {

test/adapters/ScaledApi3FeedProxyV1.sol.ts

@@ -88,9 +88,20 @@ describe('ScaledApi3FeedProxyV1', function () {
   describe('constructor', function () {
     context('proxy is not zero address', function () {
       context('targetDecimals is not invalid', function () {
-        it('constructs', async function () {
-          const { api3ReaderProxyV1, scaledApi3FeedProxyV1 } = await helpers.loadFixture(deploy);
-          expect(await scaledApi3FeedProxyV1.proxy()).to.equal(await api3ReaderProxyV1.getAddress());
+        context('targetDecimals is not 18', function () {
+          it('constructs', async function () {
+            const { api3ReaderProxyV1, scaledApi3FeedProxyV1 } = await helpers.loadFixture(deploy);
+            expect(await scaledApi3FeedProxyV1.proxy()).to.equal(await api3ReaderProxyV1.getAddress());
+          });
+        });
+        context('targetDecimals is 18', function () {
+          it('reverts', async function () {
+            const { api3ReaderProxyV1, roles } = await helpers.loadFixture(deploy);
+            const scaledApi3FeedProxyV1 = await ethers.getContractFactory('ScaledApi3FeedProxyV1', roles.deployer);
+            await expect(scaledApi3FeedProxyV1.deploy(await api3ReaderProxyV1.getAddress(), 18))
+              .to.be.revertedWithCustomError(scaledApi3FeedProxyV1, 'NoScalingNeeded')
+              .withArgs();
+          });
         });
       });
       context('targetDecimals is invalid', function () {