```\n    function getStablePoolTokenPrice(\n        address,\n        uint8 outputDecimals_,\n        bytes calldata params_\n    ) external view returns (uint256) {\n        // Prevent overflow\n        if (outputDecimals_ > BASE_10_MAX_EXPONENT)\n            revert Balancer_OutputDecimalsOutOfBounds(outputDecimals_, BASE_10_MAX_EXPONENT);\n\n\n        address[] memory tokens;\n        uint256 poolRate; // pool decimals\n        uint8 poolDecimals;\n        bytes32 poolId;\n        {\n\n        // rest of code// rest of code\n\n            // Get tokens in the pool from vault\n            (address[] memory tokens_, , ) = balVault.getPoolTokens(poolId);\n            tokens = tokens_;\n\n            // Get rate\n            try pool.getRate() returns (uint256 rate_) {\n                if (rate_ == 0) {\n                    revert Balancer_PoolStableRateInvalid(poolId, 0);\n                }\n\n\n                poolRate = rate_;\n\n        // rest of code// rest of code\n\n        uint256 minimumPrice; // outputDecimals_\n        {\n            /**\n             * The Balancer docs do not currently state this, but a historical version noted\n             * that getRate() should be multiplied by the minimum price of the tokens in the\n             * pool in order to get a valuation. This is the same approach as used by Curve stable pools.\n             */\n            for (uint256 i; i < len; i++) {\n                address token = tokens[i];\n                if (token == address(0)) revert Balancer_PoolTokenInvalid(poolId, i, token);\n\n                (uint256 price_, ) = _PRICE().getPrice(token, PRICEv2.Variant.CURRENT); // outputDecimals_\n\n\n                if (minimumPrice == 0) {\n                    minimumPrice = price_;\n                } else if (price_ < minimumPrice) {\n                    minimumPrice = price_;\n                }\n            }\n        }\n\n        uint256 poolValue = poolRate.mulDiv(minimumPrice, 10 ** poolDecimals); // outputDecimals_\n```\n