diff --git a/example/app/src/screens/advanced/customGestureHandling/CustomGestureHandling.tsx b/example/app/src/screens/advanced/customGestureHandling/CustomGestureHandling.tsx
deleted file mode 100644
index ec3a4ea14..000000000
--- a/example/app/src/screens/advanced/customGestureHandling/CustomGestureHandling.tsx
+++ /dev/null
@@ -1,115 +0,0 @@
-import React, { useCallback, useMemo, useRef } from 'react';
-import { StyleSheet, View } from 'react-native';
-import { useAnimatedProps, useSharedValue } from 'react-native-reanimated';
-import BottomSheet, {
-  BottomSheetScrollView,
-  SCROLLABLE_STATE,
-  useBottomSheetInternal,
-} from '@gorhom/bottom-sheet';
-import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import { Button } from '../../../components/button';
-import { ContactItem } from '../../../components/contactItem';
-import { createContactListMockData } from '../../../utilities/createMockData';
-import { GestureTranslationProvider } from './GestureTranslationContext';
-import { useCustomGestureEventsHandlers } from './useCustomGestureEventsHandlers';
-import { useCustomScrollEventsHandlers } from './useCustomScrollEventsHandlers';
-
-const count = 60;
-
-const CustomGestureHandling = () => {
-  // refs
-  const bottomSheetRef = useRef<BottomSheet>(null);
-
-  // variables
-  const snapPoints = useMemo(() => ['25%', '75%', '100%'], []);
-  const gestureTranslationY = useSharedValue(0);
-
-  //#region callbacks
-  const handleSnapPress = useCallback(index => {
-    bottomSheetRef.current?.snapToIndex(index);
-  }, []);
-  const handleExpandPress = useCallback(() => {
-    bottomSheetRef.current?.expand();
-  }, []);
-  const handleCollapsePress = useCallback(() => {
-    bottomSheetRef.current?.collapse();
-  }, []);
-  const handleClosePress = useCallback(() => {
-    bottomSheetRef.current?.close();
-  }, []);
-  //#endregion
-
-  return (
-    <View style={styles.container}>
-      <Button label="Snap To 100%" onPress={() => handleSnapPress(2)} />
-      <Button label="Snap To 75%" onPress={() => handleSnapPress(1)} />
-      <Button label="Snap To 25%" onPress={() => handleSnapPress(0)} />
-      <Button label="Expand" onPress={handleExpandPress} />
-      <Button label="Collapse" onPress={handleCollapsePress} />
-      <Button label="Close" onPress={handleClosePress} />
-      <GestureTranslationProvider value={gestureTranslationY}>
-        <BottomSheet
-          ref={bottomSheetRef}
-          snapPoints={snapPoints}
-          gestureEventsHandlersHook={useCustomGestureEventsHandlers}
-        >
-          <BottomSheetContent />
-        </BottomSheet>
-      </GestureTranslationProvider>
-    </View>
-  );
-};
-
-const BottomSheetContent = () => {
-  const { bottom: bottomSafeArea } = useSafeAreaInsets();
-  const data = useMemo(() => createContactListMockData(count), []);
-
-  const listContentContainerStyle = useMemo(
-    () => [styles.listContentContainer, { paddingBottom: bottomSafeArea }],
-    [bottomSafeArea]
-  );
-
-  const renderScrollViewItem = useCallback(
-    (item, index) => (
-      <ContactItem
-        key={`${item.name}.${index}`}
-        title={`${index}: ${item.name}`}
-        subTitle={item.jobTitle}
-      />
-    ),
-    []
-  );
-
-  const { animatedScrollableState } = useBottomSheetInternal();
-
-  const scrollableAnimatedProps = useAnimatedProps(() => ({
-    showsVerticalScrollIndicator:
-      animatedScrollableState.value === SCROLLABLE_STATE.UNLOCKED,
-  }));
-
-  return (
-    <BottomSheetScrollView
-      style={styles.listContainer}
-      bounces={true}
-      contentContainerStyle={listContentContainerStyle}
-      scrollEventsHandlersHook={useCustomScrollEventsHandlers}
-      animatedProps={scrollableAnimatedProps}
-    >
-      {data.map(renderScrollViewItem)}
-    </BottomSheetScrollView>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    padding: 24,
-  },
-  listContainer: {},
-  listContentContainer: {
-    overflow: 'visible',
-    paddingHorizontal: 16,
-  },
-});
-
-export default CustomGestureHandling;
diff --git a/example/app/src/screens/advanced/customGestureHandling/GestureTranslationContext.tsx b/example/app/src/screens/advanced/customGestureHandling/GestureTranslationContext.tsx
deleted file mode 100644
index 2afbab066..000000000
--- a/example/app/src/screens/advanced/customGestureHandling/GestureTranslationContext.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-import React, { useContext } from 'react';
-import Animated from 'react-native-reanimated';
-
-const gestureTranslationContext = React.createContext<
-  Animated.SharedValue<number>
->({ value: 0 });
-
-export const GestureTranslationProvider = gestureTranslationContext.Provider;
-
-export const useGestureTranslationY = () => {
-  return useContext(gestureTranslationContext);
-};
diff --git a/example/app/src/screens/advanced/customGestureHandling/useCustomGestureEventsHandlers.ts b/example/app/src/screens/advanced/customGestureHandling/useCustomGestureEventsHandlers.ts
deleted file mode 100644
index a171012ed..000000000
--- a/example/app/src/screens/advanced/customGestureHandling/useCustomGestureEventsHandlers.ts
+++ /dev/null
@@ -1,356 +0,0 @@
-import { Keyboard, Platform } from 'react-native';
-import { runOnJS, useWorkletCallback } from 'react-native-reanimated';
-import { clamp, snapPoint } from 'react-native-redash';
-import {
-  useBottomSheetInternal,
-  GESTURE_SOURCE,
-  KEYBOARD_STATE,
-  SCROLLABLE_TYPE,
-  WINDOW_HEIGHT,
-  GestureEventHandlerCallbackType,
-  ANIMATION_SOURCE,
-} from '@gorhom/bottom-sheet';
-import { useGestureTranslationY } from './GestureTranslationContext';
-
-const dismissKeyboardOnJs = runOnJS(Keyboard.dismiss);
-
-export const useCustomGestureEventsHandlers = () => {
-  // hooks
-  const gestureTranslationY = useGestureTranslationY();
-  const {
-    animatedPosition,
-    animatedSnapPoints,
-    animatedKeyboardState,
-    animatedKeyboardHeight,
-    animatedContainerHeight,
-    animatedScrollableType,
-    animatedHighestSnapPoint,
-    animatedClosedPosition,
-    animatedScrollableContentOffsetY,
-    enableOverDrag,
-    enablePanDownToClose,
-    overDragResistanceFactor,
-    isInTemporaryPosition,
-    isScrollableRefreshable,
-    animateToPosition,
-    stopAnimation,
-  } = useBottomSheetInternal();
-
-  //#region gesture methods
-  const handleOnStart: GestureEventHandlerCallbackType = useWorkletCallback(
-    function handleOnStart(_, { translationY }, context) {
-      // cancel current animation
-      stopAnimation();
-
-      // store current animated position
-      context.initialPosition = animatedPosition.value;
-      context.initialKeyboardState = animatedKeyboardState.value;
-
-      /**
-       * if the scrollable content is scrolled, then
-       * we lock the position.
-       */
-      if (animatedScrollableContentOffsetY.value > 0) {
-        context.isScrollablePositionLocked = true;
-      }
-      gestureTranslationY.value = translationY;
-    },
-    [animatedPosition, animatedKeyboardState, animatedScrollableContentOffsetY]
-  );
-  const handleOnActive: GestureEventHandlerCallbackType = useWorkletCallback(
-    function handleOnActive(source, { translationY }, context) {
-      gestureTranslationY.value = translationY;
-
-      let highestSnapPoint =
-        animatedSnapPoints.value[animatedSnapPoints.value.length - 1];
-      /**
-       * if keyboard is shown, then we set the highest point to the current
-       * position which includes the keyboard height.
-       */
-      if (
-        isInTemporaryPosition.value &&
-        context.initialKeyboardState === KEYBOARD_STATE.SHOWN
-      ) {
-        highestSnapPoint = context.initialPosition;
-      }
-
-      /**
-       * if current position is out of provided `snapPoints` and smaller then
-       * highest snap pont, then we set the highest point to the current position.
-       */
-      if (
-        isInTemporaryPosition.value &&
-        context.initialPosition < highestSnapPoint
-      ) {
-        highestSnapPoint = context.initialPosition;
-      }
-
-      const lowestSnapPoint = enablePanDownToClose
-        ? animatedContainerHeight.value
-        : animatedSnapPoints.value[0];
-
-      /**
-       * if scrollable is refreshable and sheet position at the highest
-       * point, then do not interact with current gesture.
-       */
-      if (
-        source === GESTURE_SOURCE.SCROLLABLE &&
-        isScrollableRefreshable.value &&
-        animatedPosition.value === highestSnapPoint
-      ) {
-        return;
-      }
-
-      /**
-       * a negative scrollable content offset to be subtracted from accumulated
-       * current position and gesture translation Y to allow user to drag the sheet,
-       * when scrollable position at the top.
-       * a negative scrollable content offset when the scrollable is not locked.
-       */
-      const negativeScrollableContentOffset =
-        (context.initialPosition === highestSnapPoint &&
-          source === GESTURE_SOURCE.SCROLLABLE) ||
-        !context.isScrollablePositionLocked
-          ? animatedScrollableContentOffsetY.value * -1
-          : 0;
-
-      /**
-       * an accumulated value of starting position with gesture translation y.
-       */
-      const draggedPosition = context.initialPosition + translationY;
-
-      /**
-       * an accumulated value of dragged position and negative scrollable content offset,
-       * this will insure locking sheet position when user is scrolling the scrollable until,
-       * they reach to the top of the scrollable.
-       */
-      const accumulatedDraggedPosition =
-        draggedPosition + negativeScrollableContentOffset;
-
-      /**
-       * a clamped value of the accumulated dragged position, to insure keeping the dragged
-       * position between the highest and middle snap points.
-       */
-      const secondHighestSnapPoint =
-        animatedSnapPoints.value[animatedSnapPoints.value.length - 2];
-      const isDraggingFromBottom =
-        context.initialPosition > secondHighestSnapPoint;
-
-      const clampedPosition = (() => {
-        if (source === GESTURE_SOURCE.SCROLLABLE) {
-          const clampSource = (() => {
-            if (isDraggingFromBottom) {
-              return accumulatedDraggedPosition;
-            }
-            return Math.min(draggedPosition, secondHighestSnapPoint);
-          })();
-          return clamp(clampSource, highestSnapPoint, lowestSnapPoint);
-        } else {
-          return clamp(
-            accumulatedDraggedPosition,
-            highestSnapPoint,
-            lowestSnapPoint
-          );
-        }
-      })();
-
-      /**
-       * if scrollable position is locked and the animated position
-       * reaches the highest point, then we unlock the scrollable position.
-       */
-      if (
-        context.isScrollablePositionLocked &&
-        source === GESTURE_SOURCE.SCROLLABLE &&
-        animatedPosition.value === highestSnapPoint
-      ) {
-        context.isScrollablePositionLocked = false;
-      }
-
-      /**
-       * over-drag implementation.
-       */
-      if (enableOverDrag) {
-        if (
-          (source === GESTURE_SOURCE.HANDLE ||
-            animatedScrollableType.value === SCROLLABLE_TYPE.VIEW) &&
-          draggedPosition < highestSnapPoint
-        ) {
-          const resistedPosition =
-            highestSnapPoint -
-            Math.sqrt(1 + (highestSnapPoint - draggedPosition)) *
-              overDragResistanceFactor;
-          animatedPosition.value = resistedPosition;
-          return;
-        }
-
-        if (
-          source === GESTURE_SOURCE.HANDLE &&
-          draggedPosition > lowestSnapPoint
-        ) {
-          const resistedPosition =
-            lowestSnapPoint +
-            Math.sqrt(1 + (draggedPosition - lowestSnapPoint)) *
-              overDragResistanceFactor;
-          animatedPosition.value = resistedPosition;
-          return;
-        }
-      }
-
-      animatedPosition.value = clampedPosition;
-    },
-    [
-      enableOverDrag,
-      enablePanDownToClose,
-      overDragResistanceFactor,
-      animatedContainerHeight,
-      animatedKeyboardState,
-      animatedPosition,
-      animatedSnapPoints,
-      isInTemporaryPosition,
-      isScrollableRefreshable,
-      animatedScrollableContentOffsetY,
-    ]
-  );
-  const handleOnEnd: GestureEventHandlerCallbackType = useWorkletCallback(
-    function handleOnEnd(
-      source,
-      { translationY, absoluteY, velocityY },
-      context
-    ) {
-      const highestSnapPoint = animatedHighestSnapPoint.value;
-      const isSheetAtHighestSnapPoint =
-        animatedPosition.value === highestSnapPoint;
-      /**
-       * if the sheet is in a temporary position and the gesture ended above
-       * the current position, then we snap back to the temporary position.
-       */
-      if (
-        isInTemporaryPosition.value &&
-        context.initialPosition >= animatedPosition.value
-      ) {
-        if (context.initialPosition > animatedPosition.value) {
-          animateToPosition(
-            context.initialPosition,
-            ANIMATION_SOURCE.GESTURE,
-            velocityY / 2
-          );
-        }
-        return;
-      }
-
-      /**
-       * close keyboard if current position is below the recorded
-       * start position and keyboard still shown.
-       */
-      const isScrollable =
-        animatedScrollableType.value !== SCROLLABLE_TYPE.UNDETERMINED &&
-        animatedScrollableType.value !== SCROLLABLE_TYPE.VIEW;
-
-      /**
-       * if keyboard is shown and the sheet is dragged down,
-       * then we dismiss the keyboard.
-       */
-      if (
-        context.initialKeyboardState === KEYBOARD_STATE.SHOWN &&
-        animatedPosition.value > context.initialPosition
-      ) {
-        /**
-         * if the platform is ios, current content is scrollable and
-         * the end touch point is below the keyboard position then
-         * we exit the method.
-         *
-         * because the the keyboard dismiss is interactive in iOS.
-         */
-        if (
-          !(
-            Platform.OS === 'ios' &&
-            isScrollable &&
-            absoluteY > WINDOW_HEIGHT - animatedKeyboardHeight.value
-          )
-        ) {
-          dismissKeyboardOnJs();
-        }
-      }
-
-      /**
-       * reset isInTemporaryPosition value
-       */
-      if (isInTemporaryPosition.value) {
-        isInTemporaryPosition.value = false;
-      }
-
-      /**
-       * clone snap points array, and insert the container height
-       * if pan down to close is enabled.
-       */
-      const snapPoints = animatedSnapPoints.value.slice();
-      if (enablePanDownToClose) {
-        snapPoints.unshift(animatedClosedPosition.value);
-      }
-
-      /**
-       * calculate the destination point, using redash.
-       */
-      const isDraggingDown = translationY > 0;
-
-      const destinationPoint = (() => {
-        const endingSnapPoint = snapPoint(
-          translationY + context.initialPosition,
-          velocityY,
-          snapPoints
-        );
-        if (source === GESTURE_SOURCE.HANDLE) {
-          return endingSnapPoint;
-        }
-        const secondHighestSnapPoint =
-          animatedSnapPoints.value[animatedSnapPoints.value.length - 2];
-        return isDraggingDown
-          ? Math.min(secondHighestSnapPoint, endingSnapPoint)
-          : endingSnapPoint;
-      })();
-
-      /**
-       * if destination point is the same as the current position,
-       * then no need to perform animation.
-       */
-      if (destinationPoint === animatedPosition.value) {
-        return;
-      }
-
-      const wasGestureHandledByScrollView =
-        source === GESTURE_SOURCE.SCROLLABLE &&
-        animatedScrollableContentOffsetY.value > 0;
-      /**
-       * prevents snapping from top to middle / bottom with repeated interrupted scrolls
-       */
-      if (wasGestureHandledByScrollView && isSheetAtHighestSnapPoint) {
-        return;
-      }
-
-      animateToPosition(
-        destinationPoint,
-        ANIMATION_SOURCE.GESTURE,
-        velocityY / 2
-      );
-    },
-    [
-      enablePanDownToClose,
-      animateToPosition,
-      animatedClosedPosition,
-      animatedHighestSnapPoint,
-      animatedKeyboardHeight,
-      animatedPosition,
-      animatedScrollableType,
-      animatedSnapPoints,
-      animatedScrollableContentOffsetY,
-      isInTemporaryPosition,
-      isScrollableRefreshable,
-    ]
-  );
-
-  return {
-    handleOnStart,
-    handleOnActive,
-    handleOnEnd,
-  };
-};
diff --git a/example/app/src/screens/advanced/customGestureHandling/useCustomScrollEventsHandlers.tsx b/example/app/src/screens/advanced/customGestureHandling/useCustomScrollEventsHandlers.tsx
deleted file mode 100644
index 3395f3926..000000000
--- a/example/app/src/screens/advanced/customGestureHandling/useCustomScrollEventsHandlers.tsx
+++ /dev/null
@@ -1,209 +0,0 @@
-import Animated, {
-  scrollTo,
-  useWorkletCallback,
-} from 'react-native-reanimated';
-import {
-  useBottomSheetInternal,
-  ANIMATION_STATE,
-  SCROLLABLE_STATE,
-  ScrollEventHandlerCallbackType,
-  ScrollEventsHandlersHookType,
-} from '@gorhom/bottom-sheet';
-import { useGestureTranslationY } from './GestureTranslationContext';
-
-type ScrollEventContextType = {
-  initialContentOffsetY: number;
-  startedIndex: number;
-};
-
-type GetMetadataParams = {
-  context: ScrollEventContextType;
-  gestureTranslationY: Animated.SharedValue<number>;
-  animatedSnapPoints: Animated.SharedValue<number[]>;
-};
-
-function getScrollMetadata({
-  gestureTranslationY,
-  animatedSnapPoints,
-  context,
-}: GetMetadataParams) {
-  'worklet';
-  const isDraggingDown = gestureTranslationY.value > 0;
-  const didStartAtMiddle = context.startedIndex === 1;
-  const isDraggingDownFromMiddle = isDraggingDown && didStartAtMiddle;
-  const isDraggingDownFromTop = isDraggingDown && context.startedIndex === 2;
-  const secondHighestSnapPoint =
-    animatedSnapPoints.value[animatedSnapPoints.value.length - 2];
-  const didDragBelowSecondSnapPoint =
-    gestureTranslationY.value > secondHighestSnapPoint;
-
-  const ret = {
-    isDraggingDownFromMiddle,
-    isDraggingDownFromTop,
-    didStartAtMiddle,
-    didDragBelowSecondSnapPoint,
-  };
-  return ret;
-}
-
-export const useCustomScrollEventsHandlers: ScrollEventsHandlersHookType = (
-  scrollableRef,
-  scrollableContentOffsetY: Animated.SharedValue<number>
-) => {
-  // hooks
-  const {
-    animatedScrollableState,
-    animatedAnimationState,
-    animatedScrollableContentOffsetY: rootScrollableContentOffsetY,
-    animatedScrollableOverrideState,
-    animatedIndex,
-    animatedSnapPoints,
-  } = useBottomSheetInternal();
-  const gestureTranslationY = useGestureTranslationY();
-
-  // callbacks
-  const handleOnBeginDrag: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      ({ contentOffset: { y } }, context) => {
-        scrollableContentOffsetY.value = y;
-        rootScrollableContentOffsetY.value = y;
-        context.initialContentOffsetY = y;
-        context.startedIndex = animatedIndex.value;
-      },
-      [animatedIndex, rootScrollableContentOffsetY, scrollableContentOffsetY]
-    );
-  const handleOnScroll: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      (_, context) => {
-        const {
-          didDragBelowSecondSnapPoint,
-          isDraggingDownFromMiddle,
-          isDraggingDownFromTop,
-        } = getScrollMetadata({
-          context,
-          animatedSnapPoints,
-          gestureTranslationY,
-        });
-
-        /**
-         * override scrollable state.
-         */
-        if (isDraggingDownFromMiddle) {
-          animatedScrollableOverrideState.value = SCROLLABLE_STATE.UNLOCKED;
-        } else {
-          animatedScrollableOverrideState.value = SCROLLABLE_STATE.UNDETERMINED;
-        }
-
-        if (
-          isDraggingDownFromMiddle ||
-          (isDraggingDownFromTop && didDragBelowSecondSnapPoint)
-        ) {
-          return;
-        }
-
-        if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
-          const lockPosition = context.initialContentOffsetY ?? 0;
-          // @ts-ignore
-          scrollTo(scrollableRef, 0, lockPosition, false);
-          scrollableContentOffsetY.value = lockPosition;
-          return;
-        }
-      },
-      [
-        scrollableRef,
-        scrollableContentOffsetY,
-        animatedScrollableState,
-        animatedSnapPoints,
-        gestureTranslationY,
-      ]
-    );
-  const handleOnEndDrag: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      ({ contentOffset: { y } }, context) => {
-        const {
-          didStartAtMiddle,
-          didDragBelowSecondSnapPoint,
-          isDraggingDownFromTop,
-        } = getScrollMetadata({
-          context,
-          animatedSnapPoints,
-          gestureTranslationY,
-        });
-
-        if (
-          didStartAtMiddle ||
-          (isDraggingDownFromTop && didDragBelowSecondSnapPoint)
-        ) {
-          return;
-        }
-        if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
-          const lockPosition = context.initialContentOffsetY ?? 0;
-          // @ts-ignore
-          scrollTo(scrollableRef, 0, lockPosition, false);
-          scrollableContentOffsetY.value = lockPosition;
-          return;
-        }
-        if (animatedAnimationState.value !== ANIMATION_STATE.RUNNING) {
-          scrollableContentOffsetY.value = y;
-          rootScrollableContentOffsetY.value = y;
-        }
-      },
-      [
-        animatedAnimationState,
-        animatedScrollableState,
-        animatedSnapPoints,
-        gestureTranslationY,
-        rootScrollableContentOffsetY,
-        scrollableContentOffsetY,
-        scrollableRef,
-      ]
-    );
-  const handleOnMomentumEnd: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      ({ contentOffset: { y } }, context) => {
-        const {
-          didStartAtMiddle,
-          didDragBelowSecondSnapPoint,
-          isDraggingDownFromTop,
-        } = getScrollMetadata({
-          context,
-          animatedSnapPoints,
-          gestureTranslationY,
-        });
-
-        if (
-          didStartAtMiddle ||
-          (isDraggingDownFromTop && didDragBelowSecondSnapPoint)
-        ) {
-          return;
-        }
-        if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
-          const lockPosition = context.initialContentOffsetY ?? 0;
-          // @ts-ignore
-          scrollTo(scrollableRef, 0, lockPosition, false);
-          scrollableContentOffsetY.value = 0;
-          return;
-        }
-        if (animatedAnimationState.value !== ANIMATION_STATE.RUNNING) {
-          scrollableContentOffsetY.value = y;
-          rootScrollableContentOffsetY.value = y;
-        }
-      },
-      [
-        scrollableRef,
-        scrollableContentOffsetY,
-        animatedAnimationState,
-        animatedScrollableState,
-        animatedSnapPoints,
-        gestureTranslationY,
-        rootScrollableContentOffsetY,
-      ]
-    );
-
-  return {
-    handleOnBeginDrag,
-    handleOnScroll,
-    handleOnEndDrag,
-    handleOnMomentumEnd,
-  };
-};
diff --git a/example/app/src/screens/index.ts b/example/app/src/screens/index.ts
index 251901990..08856befd 100644
--- a/example/app/src/screens/index.ts
+++ b/example/app/src/screens/index.ts
@@ -112,13 +112,6 @@ export const screens = [
         slug: 'Advanced/PullToRefreshExample',
         getScreen: () => require('./advanced/PullToRefreshExample').default,
       },
-      {
-        name: 'Custom Gesture Handling',
-        slug: 'Advanced/CustomGestureHandling',
-        getScreen: () =>
-          require('./advanced/customGestureHandling/CustomGestureHandling')
-            .default,
-      },
     ] as ShowcaseExampleScreenType[],
   },
 ];
diff --git a/src/components/bottomSheet/BottomSheet.tsx b/src/components/bottomSheet/BottomSheet.tsx
index 36d676085..2a41533c5 100644
--- a/src/components/bottomSheet/BottomSheet.tsx
+++ b/src/components/bottomSheet/BottomSheet.tsx
@@ -5,6 +5,7 @@ import React, {
   useImperativeHandle,
   memo,
   useEffect,
+  useRef,
 } from 'react';
 import { Platform } from 'react-native';
 import invariant from 'invariant';
@@ -21,6 +22,7 @@ import Animated, {
   useWorkletCallback,
   WithSpringConfig,
   WithTimingConfig,
+  isSharedValue,
 } from 'react-native-reanimated';
 import { State } from 'react-native-gesture-handler';
 import {
@@ -34,7 +36,10 @@ import {
   BottomSheetInternalProvider,
   BottomSheetProvider,
 } from '../../contexts';
-import type { BottomSheetInternalContextType } from '../../contexts/internal';
+import type {
+  BottomSheetInternalContextType,
+  ProvidedScrollHandlers,
+} from '../../contexts/internal';
 import BottomSheetContainer from '../bottomSheetContainer';
 import BottomSheetGestureHandlersProvider from '../bottomSheetGestureHandlersProvider';
 import BottomSheetBackdropContainer from '../bottomSheetBackdropContainer';
@@ -78,7 +83,7 @@ import {
   DEFAULT_DYNAMIC_SIZING,
   DEFAULT_ACCESSIBLE,
   DEFAULT_ACCESSIBILITY_LABEL,
-  DEFAULT_ACCESSIBILITY_ROLE
+  DEFAULT_ACCESSIBILITY_ROLE,
 } from './constants';
 import type { BottomSheetMethods, Insets } from '../../types';
 import type { BottomSheetProps, AnimateToPositionType } from './types';
@@ -294,14 +299,13 @@ const BottomSheetComponent = forwardRef<BottomSheet, BottomSheetProps>(
     //#region hooks variables
     // scrollable variables
     const {
+      scrollableRef,
       animatedScrollableType,
       animatedScrollableContentOffsetY,
       animatedScrollableOverrideState,
       isScrollableRefreshable,
       isScrollableLocked,
       isScrollEnded,
-      setScrollableRef,
-      removeScrollableRef,
     } = useScrollable();
     // keyboard
     const {
@@ -411,7 +415,12 @@ const BottomSheetComponent = forwardRef<BottomSheet, BottomSheetProps>(
         return SCROLLABLE_STATE.UNLOCKED;
       }
 
-      return SCROLLABLE_STATE.LOCKED;
+      const enableContentPanning = isSharedValue(enableContentPanningGesture)
+        ? enableContentPanningGesture.value
+        : enableContentPanningGesture;
+      return enableContentPanning
+        ? SCROLLABLE_STATE.LOCKED
+        : SCROLLABLE_STATE.UNLOCKED;
     });
     // dynamic
     const animatedContentHeightMax = useDerivedValue(() => {
@@ -627,7 +636,11 @@ const BottomSheetComponent = forwardRef<BottomSheet, BottomSheetProps>(
       [_providedOnChange, animatedCurrentIndex]
     );
     const handleOnAnimate = useCallback(
-      function handleOnAnimate(toPoint: number, source: ANIMATION_SOURCE, snapPoints: number[]) {
+      function handleOnAnimate(
+        toPoint: number,
+        source: ANIMATION_SOURCE,
+        snapPoints: number[]
+      ) {
         const closedPosition = animatedClosedPosition.value;
         const toIndex =
           toPoint === closedPosition ? -1 : snapPoints.indexOf(toPoint);
@@ -1078,6 +1091,8 @@ const BottomSheetComponent = forwardRef<BottomSheet, BottomSheetProps>(
     }));
     //#endregion
 
+    const scrollHandlersRef = useRef<ProvidedScrollHandlers | null>(null);
+
     //#region contexts variables
     const internalContextVariables = useMemo<BottomSheetInternalContextType>(
       () => ({
@@ -1120,8 +1135,8 @@ const BottomSheetComponent = forwardRef<BottomSheet, BottomSheetProps>(
         failOffsetY: _providedFailOffsetY,
         animateToPosition,
         stopAnimation,
-        setScrollableRef,
-        removeScrollableRef,
+        scrollableRef,
+        scrollHandlersRef,
       }),
       [
         animatedIndex,
@@ -1161,10 +1176,10 @@ const BottomSheetComponent = forwardRef<BottomSheet, BottomSheetProps>(
         _providedActiveOffsetY,
         _providedFailOffsetX,
         _providedFailOffsetY,
-        setScrollableRef,
-        removeScrollableRef,
         animateToPosition,
         stopAnimation,
+        scrollableRef,
+        scrollHandlersRef,
       ]
     );
     const externalContextVariables = useMemo(
diff --git a/src/components/bottomSheet/types.d.ts b/src/components/bottomSheet/types.d.ts
index 516497651..858dc03fb 100644
--- a/src/components/bottomSheet/types.d.ts
+++ b/src/components/bottomSheet/types.d.ts
@@ -81,7 +81,7 @@ export interface BottomSheetProps
    * @type boolean
    * @default true
    */
-  enableContentPanningGesture?: boolean;
+  enableContentPanningGesture?: boolean | SharedValue<boolean>;
   /**
    * Enable handle panning gesture interaction.
    * @type boolean
diff --git a/src/components/bottomSheetDraggableView/BottomSheetDraggableView.tsx b/src/components/bottomSheetDraggableView/BottomSheetDraggableView.tsx
index 377b2d5a8..d227e0c60 100644
--- a/src/components/bottomSheetDraggableView/BottomSheetDraggableView.tsx
+++ b/src/components/bottomSheetDraggableView/BottomSheetDraggableView.tsx
@@ -1,5 +1,5 @@
 import React, { useMemo, useRef, memo } from 'react';
-import Animated from 'react-native-reanimated';
+import Animated, { type AnimatedRef } from 'react-native-reanimated';
 import { PanGestureHandler } from 'react-native-gesture-handler';
 import {
   useBottomSheetGestureHandlers,
@@ -10,7 +10,6 @@ import type { BottomSheetDraggableViewProps } from './types';
 
 const BottomSheetDraggableViewComponent = ({
   gestureType = GESTURE_SOURCE.CONTENT,
-  nativeGestureRef,
   refreshControlGestureRef,
   style,
   children,
@@ -18,7 +17,7 @@ const BottomSheetDraggableViewComponent = ({
 }: BottomSheetDraggableViewProps) => {
   //#region hooks
   const {
-    enableContentPanningGesture,
+    scrollableRef,
     simultaneousHandlers: _providedSimultaneousHandlers,
     waitFor,
     activeOffsetX,
@@ -40,11 +39,7 @@ const BottomSheetDraggableViewComponent = ({
     [gestureType, contentPanGestureHandler, scrollablePanGestureHandler]
   );
   const simultaneousHandlers = useMemo(() => {
-    const refs = [];
-
-    if (nativeGestureRef) {
-      refs.push(nativeGestureRef);
-    }
+    const refs: (AnimatedRef<any> | React.Ref<any>)[] = [scrollableRef];
 
     if (refreshControlGestureRef) {
       refs.push(refreshControlGestureRef);
@@ -59,17 +54,12 @@ const BottomSheetDraggableViewComponent = ({
     }
 
     return refs;
-  }, [
-    _providedSimultaneousHandlers,
-    nativeGestureRef,
-    refreshControlGestureRef,
-  ]);
+  }, [_providedSimultaneousHandlers, refreshControlGestureRef]);
   //#endregion
 
   return (
     <PanGestureHandler
       ref={panGestureRef}
-      enabled={enableContentPanningGesture}
       simultaneousHandlers={simultaneousHandlers}
       shouldCancelWhenOutside={false}
       waitFor={waitFor}
diff --git a/src/components/bottomSheetDraggableView/types.d.ts b/src/components/bottomSheetDraggableView/types.d.ts
index 8d38987e2..e8dca263c 100644
--- a/src/components/bottomSheetDraggableView/types.d.ts
+++ b/src/components/bottomSheetDraggableView/types.d.ts
@@ -11,7 +11,6 @@ export type BottomSheetDraggableViewProps = RNViewProps & {
    * @type GESTURE_SOURCE
    */
   gestureType?: GESTURE_SOURCE;
-  nativeGestureRef?: Ref<NativeViewGestureHandler> | null;
   refreshControlGestureRef?: Ref<NativeViewGestureHandler> | null;
   children: ReactNode[] | ReactNode;
 };
diff --git a/src/components/bottomSheetGestureHandlersProvider/BottomSheetGestureHandlersProvider.tsx b/src/components/bottomSheetGestureHandlersProvider/BottomSheetGestureHandlersProvider.tsx
index e3314b812..f983d91d1 100644
--- a/src/components/bottomSheetGestureHandlersProvider/BottomSheetGestureHandlersProvider.tsx
+++ b/src/components/bottomSheetGestureHandlersProvider/BottomSheetGestureHandlersProvider.tsx
@@ -23,7 +23,7 @@ const BottomSheetGestureHandlersProvider = ({
   //#region hooks
   const { animatedContentGestureState, animatedHandleGestureState } =
     useBottomSheetInternal();
-  const { handleOnStart, handleOnActive, handleOnEnd } =
+  const { handleOnStart, handleOnActive, handleOnEnd, animatedScrollHandler } =
     useGestureEventsHandlers();
   //#endregion
 
@@ -63,12 +63,14 @@ const BottomSheetGestureHandlersProvider = ({
       handlePanGestureHandler,
       scrollablePanGestureHandler,
       animatedGestureSource,
+      animatedScrollHandler,
     }),
     [
       contentPanGestureHandler,
       handlePanGestureHandler,
       scrollablePanGestureHandler,
       animatedGestureSource,
+      animatedScrollHandler,
     ]
   );
   //#endregion
diff --git a/src/components/bottomSheetScrollable/BottomSheetScrollView.tsx b/src/components/bottomSheetScrollable/BottomSheetScrollView.tsx
index 6463c4ddf..98223ae4d 100644
--- a/src/components/bottomSheetScrollable/BottomSheetScrollView.tsx
+++ b/src/components/bottomSheetScrollable/BottomSheetScrollView.tsx
@@ -1,8 +1,4 @@
 import { memo } from 'react';
-import {
-  ScrollView as RNScrollView,
-  ScrollViewProps as RNScrollViewProps,
-} from 'react-native';
 import Animated from 'react-native-reanimated';
 import { SCROLLABLE_TYPE } from '../../constants';
 import { createBottomSheetScrollableComponent } from './createBottomSheetScrollableComponent';
@@ -11,13 +7,10 @@ import type {
   BottomSheetScrollViewProps,
 } from './types';
 
-const AnimatedScrollView =
-  Animated.createAnimatedComponent<RNScrollViewProps>(RNScrollView);
-
 const BottomSheetScrollViewComponent = createBottomSheetScrollableComponent<
   BottomSheetScrollViewMethods,
   BottomSheetScrollViewProps
->(SCROLLABLE_TYPE.SCROLLVIEW, AnimatedScrollView);
+>(SCROLLABLE_TYPE.SCROLLVIEW, Animated.ScrollView);
 
 const BottomSheetScrollView = memo(BottomSheetScrollViewComponent);
 BottomSheetScrollView.displayName = 'BottomSheetScrollView';
diff --git a/src/components/bottomSheetScrollable/createBottomSheetScrollableComponent.tsx b/src/components/bottomSheetScrollable/createBottomSheetScrollableComponent.tsx
index bdcb48200..82d1dd70f 100644
--- a/src/components/bottomSheetScrollable/createBottomSheetScrollableComponent.tsx
+++ b/src/components/bottomSheetScrollable/createBottomSheetScrollableComponent.tsx
@@ -1,14 +1,17 @@
-import React, { forwardRef, useImperativeHandle, useMemo, useRef } from 'react';
+import React, { forwardRef, useEffect, useImperativeHandle, useMemo, useRef } from 'react';
 import { Platform } from 'react-native';
-import { useAnimatedProps, useAnimatedStyle } from 'react-native-reanimated';
-import { NativeViewGestureHandler } from 'react-native-gesture-handler';
+import {
+  type AnimatedScrollViewProps,
+  useAnimatedProps,
+  useAnimatedStyle,
+} from 'react-native-reanimated';
+import type { NativeViewGestureHandler } from 'react-native-gesture-handler';
 import BottomSheetDraggableView from '../bottomSheetDraggableView';
 import BottomSheetRefreshControl from '../bottomSheetRefreshControl';
 import {
-  useScrollHandler,
   useScrollableSetter,
   useBottomSheetInternal,
-  useStableCallback,
+  useStableCallback, useBottomSheetGestureHandlers,
 } from '../../hooks';
 import {
   GESTURE_SOURCE,
@@ -40,7 +43,6 @@ export function createBottomSheetScrollableComponent<T, P>(
       refreshControl,
       scrollBuffer,
       preserveScrollMomentum,
-      lockableScrollableContentOffsetY,
       // events
       onScroll,
       onScrollBeginDrag,
@@ -50,34 +52,43 @@ export function createBottomSheetScrollableComponent<T, P>(
     }: any = props;
 
     //#region refs
-    const nativeGestureRef = useRef<NativeViewGestureHandler>(null);
     const refreshControlGestureRef = useRef<NativeViewGestureHandler>(null);
     //#endregion
 
     //#region hooks
-    const { scrollableRef, scrollableContentOffsetY, scrollHandler } =
-      useScrollHandler(
-        scrollEventsHandlersHook,
-        onScroll,
-        onScrollBeginDrag,
-        onScrollEndDrag,
-        scrollBuffer,
-        preserveScrollMomentum,
-        lockableScrollableContentOffsetY
-      );
+    const { animatedScrollHandler: scrollHandler } = useBottomSheetGestureHandlers();
+
     const {
-      enableContentPanningGesture,
+      scrollableRef,
+      scrollHandlersRef,
       animatedFooterHeight,
+      animatedScrollableContentOffsetY,
       animatedScrollableState,
       animatedContentHeight,
       enableDynamicSizing,
     } = useBottomSheetInternal();
+
+    useEffect(() => {
+      scrollHandlersRef.current = {
+        onScroll,
+        onScrollBeginDrag,
+        onScrollEndDrag,
+      }
+    }, [onScroll, onScrollBeginDrag, onScrollEndDrag])
     //#endregion
 
     //#region variables
-    const scrollableAnimatedProps = useAnimatedProps(
+    const scrollableAnimatedProps = useAnimatedProps<AnimatedScrollViewProps>(
       () => ({
-        ...(preserveScrollMomentum ? {} : {decelerationRate: SCROLLABLE_DECELERATION_RATE_MAPPER[animatedScrollableState.value]}),
+        scrollEnabled: animatedScrollableState.value !== SCROLLABLE_STATE.LOCKED,
+        ...(preserveScrollMomentum
+          ? {}
+          : {
+              decelerationRate:
+                SCROLLABLE_DECELERATION_RATE_MAPPER[
+                  animatedScrollableState.value
+                ],
+            }),
         showsVerticalScrollIndicator: showsVerticalScrollIndicator
           ? animatedScrollableState.value === SCROLLABLE_STATE.UNLOCKED
           : showsVerticalScrollIndicator,
@@ -125,9 +136,8 @@ export function createBottomSheetScrollableComponent<T, P>(
     // @ts-ignore
     useImperativeHandle(ref, () => scrollableRef.current);
     useScrollableSetter(
-      scrollableRef,
       type,
-      scrollableContentOffsetY,
+      animatedScrollableContentOffsetY,
       onRefresh !== undefined,
       scrollBuffer,
       preserveScrollMomentum,
@@ -138,27 +148,19 @@ export function createBottomSheetScrollableComponent<T, P>(
     //#region render
     if (Platform.OS === 'android') {
       const scrollableContent = (
-        <NativeViewGestureHandler
-          ref={nativeGestureRef}
-          enabled={enableContentPanningGesture}
-          shouldCancelWhenOutside={false}
-        >
-          <ScrollableComponent
-            animatedProps={scrollableAnimatedProps}
-            {...rest}
-            scrollEventThrottle={16}
-            ref={scrollableRef}
-            overScrollMode={overScrollMode}
-            keyboardDismissMode={keyboardDismissMode}
-            onScroll={scrollHandler}
-            onContentSizeChange={handleContentSizeChange}
-            style={containerStyle}
-          />
-        </NativeViewGestureHandler>
+        <ScrollableComponent
+          animatedProps={scrollableAnimatedProps}
+          {...rest}
+          ref={scrollableRef}
+          overScrollMode={overScrollMode}
+          keyboardDismissMode={keyboardDismissMode}
+          onScroll={scrollHandler}
+          onContentSizeChange={handleContentSizeChange}
+          style={containerStyle}
+        />
       );
       return (
         <BottomSheetDraggableView
-          nativeGestureRef={nativeGestureRef}
           refreshControlGestureRef={refreshControlGestureRef}
           gestureType={GESTURE_SOURCE.SCROLLABLE}
           style={styles.container}
@@ -181,31 +183,23 @@ export function createBottomSheetScrollableComponent<T, P>(
     }
     return (
       <BottomSheetDraggableView
-        nativeGestureRef={nativeGestureRef}
         gestureType={GESTURE_SOURCE.SCROLLABLE}
         style={styles.container}
       >
-        <NativeViewGestureHandler
-          ref={nativeGestureRef}
-          enabled={enableContentPanningGesture}
-          shouldCancelWhenOutside={false}
-        >
-          <ScrollableComponent
-            animatedProps={scrollableAnimatedProps}
-            {...rest}
-            scrollEventThrottle={16}
-            ref={scrollableRef}
-            overScrollMode={overScrollMode}
-            keyboardDismissMode={keyboardDismissMode}
-            refreshing={refreshing}
-            onRefresh={onRefresh}
-            progressViewOffset={progressViewOffset}
-            refreshControl={refreshControl}
-            onScroll={scrollHandler}
-            onContentSizeChange={handleContentSizeChange}
-            style={containerStyle}
-          />
-        </NativeViewGestureHandler>
+        <ScrollableComponent
+          animatedProps={scrollableAnimatedProps}
+          {...rest}
+          ref={scrollableRef}
+          overScrollMode={overScrollMode}
+          keyboardDismissMode={keyboardDismissMode}
+          refreshing={refreshing}
+          onRefresh={onRefresh}
+          progressViewOffset={progressViewOffset}
+          refreshControl={refreshControl}
+          onScroll={scrollHandler}
+          onContentSizeChange={handleContentSizeChange}
+          style={containerStyle}
+        />
       </BottomSheetDraggableView>
     );
     //#endregion
diff --git a/src/components/bottomSheetScrollable/types.d.ts b/src/components/bottomSheetScrollable/types.d.ts
index e3b9831a4..7b9d110d2 100644
--- a/src/components/bottomSheetScrollable/types.d.ts
+++ b/src/components/bottomSheetScrollable/types.d.ts
@@ -39,16 +39,6 @@ export interface BottomSheetScrollableProps {
    */
   focusHook?: (effect: EffectCallback, deps?: DependencyList) => void;
 
-  /**
-   * Custom hook to provide scroll events handler, which will allow advance and
-   * customize handling for scrollables.
-   *
-   * @warning this is an experimental feature and the hook signature can change without a major version bump.
-   * @type ScrollEventsHandlersHookType
-   * @default useScrollEventsHandlersDefault
-   */
-  scrollEventsHandlersHook?: ScrollEventsHandlersHookType;
-
   /**
    * An initial scroll buffer to prevent the bottom sheet from immediately following the scroll gesture.
    */
@@ -58,11 +48,6 @@ export interface BottomSheetScrollableProps {
    * Whether or not to preserve scroll momentum when expanding a scrollable bottom sheet component.
    */
   preserveScrollMomentum?: boolean;
-
-  /**
-   * The optional lockable scrollable content offset ref, which will remain the same value when scrollable is locked.
-   */
-  lockableScrollableContentOffsetY?: Animated.SharedValue<number>;
 }
 
 export type ScrollableProps<T> =
@@ -152,9 +137,7 @@ export interface BottomSheetFlatListMethods {
 //#region FlatList
 export type BottomSheetFlashListProps<T> = Omit<
   FlashListProps<T>,
-  | 'decelerationRate'
-  | 'scrollEventThrottle'
-  | 'renderScrollComponent'
+  'decelerationRate' | 'scrollEventThrottle' | 'renderScrollComponent'
 > &
   BottomSheetScrollableProps & {
     ref?: Ref<BottomSheetFlashListMethods>;
diff --git a/src/contexts/gesture.ts b/src/contexts/gesture.ts
index 79ce72d30..5c015cfe1 100644
--- a/src/contexts/gesture.ts
+++ b/src/contexts/gesture.ts
@@ -1,10 +1,14 @@
 import { createContext } from 'react';
 import type { PanGestureHandlerGestureEvent } from 'react-native-gesture-handler';
+import type { NativeScrollEvent, NativeSyntheticEvent } from 'react-native';
 
 export interface BottomSheetGestureHandlersContextType {
   contentPanGestureHandler: (event: PanGestureHandlerGestureEvent) => void;
   handlePanGestureHandler: (event: PanGestureHandlerGestureEvent) => void;
   scrollablePanGestureHandler: (event: PanGestureHandlerGestureEvent) => void;
+  animatedScrollHandler: (
+    event: NativeSyntheticEvent<NativeScrollEvent>
+  ) => void;
 }
 
 export const BottomSheetGestureHandlersContext =
diff --git a/src/contexts/internal.ts b/src/contexts/internal.ts
index 1b2dc75ea..fd5f6140d 100644
--- a/src/contexts/internal.ts
+++ b/src/contexts/internal.ts
@@ -1,9 +1,10 @@
-import { createContext, RefObject } from 'react';
+import { createContext, type MutableRefObject } from 'react';
 import type {
   PanGestureHandlerProps,
   State,
 } from 'react-native-gesture-handler';
 import type Animated from 'react-native-reanimated';
+import type { AnimatedRef } from 'react-native-reanimated';
 import type {
   AnimateToPositionType,
   BottomSheetProps,
@@ -15,7 +16,13 @@ import type {
   SCROLLABLE_TYPE,
   SHEET_STATE,
 } from '../constants';
-import type { Scrollable, ScrollableRef } from '../types';
+import type { Scrollable, ScrollableEvent } from '../types';
+
+export interface ProvidedScrollHandlers {
+  onScroll: ScrollableEvent | undefined;
+  onScrollBeginDrag: ScrollableEvent | undefined;
+  onScrollEndDrag: ScrollableEvent | undefined;
+}
 
 export interface BottomSheetInternalContextType
   extends Pick<
@@ -70,8 +77,8 @@ export interface BottomSheetInternalContextType
   // methods
   stopAnimation: () => void;
   animateToPosition: AnimateToPositionType;
-  setScrollableRef: (ref: ScrollableRef) => void;
-  removeScrollableRef: (ref: RefObject<Scrollable>) => void;
+  scrollableRef: AnimatedRef<Scrollable>;
+  scrollHandlersRef: MutableRefObject<ProvidedScrollHandlers | null>;
 }
 
 export const BottomSheetInternalContext =
diff --git a/src/hooks/index.ts b/src/hooks/index.ts
index 52e9ec7fd..94fa25bcd 100644
--- a/src/hooks/index.ts
+++ b/src/hooks/index.ts
@@ -8,7 +8,6 @@ export { useBottomSheetModalInternal } from './useBottomSheetModalInternal';
 // scrollable
 export { useScrollable } from './useScrollable';
 export { useScrollableSetter } from './useScrollableSetter';
-export { useScrollHandler } from './useScrollHandler';
 
 // gestures
 export { useGestureHandler } from './useGestureHandler';
diff --git a/src/hooks/useGestureEventsHandlersDefault.tsx b/src/hooks/useGestureEventsHandlersDefault.tsx
index a5aa3140e..05f11539f 100644
--- a/src/hooks/useGestureEventsHandlersDefault.tsx
+++ b/src/hooks/useGestureEventsHandlersDefault.tsx
@@ -1,24 +1,34 @@
 import { Keyboard, Platform } from 'react-native';
-import { runOnJS, useWorkletCallback } from 'react-native-reanimated';
+import {
+  runOnJS,
+  useAnimatedScrollHandler,
+  useWorkletCallback,
+  scrollTo,
+} from 'react-native-reanimated';
 import { useBottomSheetInternal } from './useBottomSheetInternal';
 import {
   ANIMATION_SOURCE,
+  ANIMATION_STATE,
   GESTURE_SOURCE,
   KEYBOARD_STATE,
   SCROLLABLE_TYPE,
   WINDOW_HEIGHT,
+  SHEET_STATE,
+  SCROLLABLE_STATE,
 } from '../constants';
 import type {
   GestureEventsHandlersHookType,
   GestureEventHandlerCallbackType,
+  PanGestureEventContextType,
+  ScrollEventContextType,
 } from '../types';
 import { clamp } from '../utilities/clamp';
 import { snapPoint } from '../utilities/snapPoint';
 
-type GestureEventContextType = {
-  initialPosition: number;
-  initialKeyboardState: KEYBOARD_STATE;
-  isScrollablePositionLocked: boolean;
+const INITIAL_GESTURE_CONTEXT: PanGestureEventContextType = {
+  initialPosition: 0,
+  initialKeyboardState: KEYBOARD_STATE.UNDETERMINED,
+  isScrollablePositionLocked: false,
 };
 
 const dismissKeyboard = Keyboard.dismiss;
@@ -44,11 +54,16 @@ export const useGestureEventsHandlersDefault: GestureEventsHandlersHookType =
       isScrollableLocked,
       animateToPosition,
       stopAnimation,
+      animatedAnimationState,
+      animatedSheetState,
+      animatedScrollableState,
+      scrollableRef,
+      scrollHandlersRef,
     } = useBottomSheetInternal();
     //#endregion
 
     //#region gesture methods
-    const handleOnStart: GestureEventHandlerCallbackType<GestureEventContextType> =
+    const handleOnStart: GestureEventHandlerCallbackType<PanGestureEventContextType> =
       useWorkletCallback(
         function handleOnStart(__, _, context) {
           // cancel current animation
@@ -73,7 +88,7 @@ export const useGestureEventsHandlersDefault: GestureEventsHandlersHookType =
           animatedScrollableContentOffsetY,
         ]
       );
-    const handleOnActive: GestureEventHandlerCallbackType<GestureEventContextType> =
+    const handleOnActive: GestureEventHandlerCallbackType<PanGestureEventContextType> =
       useWorkletCallback(
         function handleOnActive(source, { translationY }, context) {
           let highestSnapPoint = animatedHighestSnapPoint.value;
@@ -120,7 +135,10 @@ export const useGestureEventsHandlersDefault: GestureEventsHandlersHookType =
            * if scrollable isn't currently marked as translatable, then do not
            * interact with current gesture.
            */
-          if (source === GESTURE_SOURCE.SCROLLABLE && !isScrollableLocked.value) {
+          if (
+            source === GESTURE_SOURCE.SCROLLABLE &&
+            !isScrollableLocked.value
+          ) {
             return;
           }
 
@@ -236,7 +254,7 @@ export const useGestureEventsHandlersDefault: GestureEventsHandlersHookType =
           animatedScrollableContentOffsetY,
         ]
       );
-    const handleOnEnd: GestureEventHandlerCallbackType<GestureEventContextType> =
+    const handleOnEnd: GestureEventHandlerCallbackType<PanGestureEventContextType> =
       useWorkletCallback(
         function handleOnEnd(
           source,
@@ -260,7 +278,10 @@ export const useGestureEventsHandlersDefault: GestureEventsHandlersHookType =
             return;
           }
 
-          if (!isScrollableLocked.value && animatedSnapPoints.value.includes(animatedPosition.value)) {
+          if (
+            !isScrollableLocked.value &&
+            animatedSnapPoints.value.includes(animatedPosition.value)
+          ) {
             return;
           }
 
@@ -382,9 +403,135 @@ export const useGestureEventsHandlersDefault: GestureEventsHandlersHookType =
       );
     //#endregion
 
+    const animatedScrollHandler =
+      useAnimatedScrollHandler<ScrollEventContextType>({
+        onScroll: (event, context) => {
+          /**
+           * if sheet position is extended or fill parent, then we reset
+           * `shouldLockInitialPosition` value to false.
+           */
+          if (
+            animatedSheetState.value === SHEET_STATE.EXTENDED ||
+            animatedSheetState.value === SHEET_STATE.FILL_PARENT
+          ) {
+            context!.shouldLockInitialPosition = false;
+          }
+
+          if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
+            const lockPosition = context!.shouldLockInitialPosition
+              ? context!.initialContentOffsetY ?? 0
+              : 0;
+            scrollTo(scrollableRef, 0, lockPosition, false);
+            animatedScrollableContentOffsetY.value = lockPosition;
+            return;
+          }
+
+          handleOnActive(
+            GESTURE_SOURCE.SCROLLABLE,
+            {
+              translationY: event.contentOffset.y,
+              velocityY: event.velocity?.y ?? 0,
+              absoluteY: 0,
+            },
+            { ...INITIAL_GESTURE_CONTEXT }
+          );
+
+          const cb = scrollHandlersRef.current?.onScroll;
+          if (cb != null) {
+            runOnJS(cb)({
+              nativeEvent: event,
+            });
+          }
+        },
+        onBeginDrag: (event, context) => {
+          const { y } = event.contentOffset;
+          animatedScrollableContentOffsetY.value = y;
+          context!.initialContentOffsetY = y;
+
+          /**
+           * if sheet position not extended or fill parent and the scrollable position
+           * not at the top, then we should lock the initial scrollable position.
+           */
+          if (
+            animatedSheetState.value !== SHEET_STATE.EXTENDED &&
+            animatedSheetState.value !== SHEET_STATE.FILL_PARENT &&
+            y > 0
+          ) {
+            context!.shouldLockInitialPosition = true;
+          } else {
+            context!.shouldLockInitialPosition = false;
+          }
+
+          handleOnStart(
+            GESTURE_SOURCE.SCROLLABLE,
+            {
+              translationY: event.contentOffset.y,
+              velocityY: event.velocity?.y ?? 0,
+              absoluteY: 9999, // makes keyboard dismiss on Android
+            },
+            { ...INITIAL_GESTURE_CONTEXT }
+          );
+
+          const cb = scrollHandlersRef.current?.onScrollBeginDrag;
+          if (cb != null) {
+            runOnJS(cb)({
+              nativeEvent: event,
+            });
+          }
+        },
+        onEndDrag: (event, context) => {
+          const { y } = event.contentOffset;
+
+          if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
+            const lockPosition = context!.shouldLockInitialPosition
+              ? context!.initialContentOffsetY ?? 0
+              : 0;
+            scrollTo(scrollableRef, 0, lockPosition, false);
+            animatedScrollableContentOffsetY.value = lockPosition;
+            return;
+          }
+          if (animatedAnimationState.value !== ANIMATION_STATE.RUNNING) {
+            animatedScrollableContentOffsetY.value = y;
+          }
+
+          handleOnEnd(
+            GESTURE_SOURCE.SCROLLABLE,
+            {
+              translationY: event.contentOffset.y,
+              absoluteY: 0,
+              velocityY: event.velocity?.y ?? 0,
+            },
+            { ...INITIAL_GESTURE_CONTEXT }
+          );
+
+          const cb = scrollHandlersRef.current?.onScrollEndDrag;
+          if (cb != null) {
+            runOnJS(cb)({
+              nativeEvent: event,
+            });
+          }
+        },
+        onMomentumEnd: (event, context) => {
+          const { y } = event.contentOffset;
+
+          if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
+            const lockPosition = context!.shouldLockInitialPosition
+              ? context!.initialContentOffsetY ?? 0
+              : 0;
+            scrollTo(scrollableRef, 0, lockPosition, false);
+            animatedScrollableContentOffsetY.value = 0;
+            return;
+          }
+          if (animatedAnimationState.value !== ANIMATION_STATE.RUNNING) {
+            animatedScrollableContentOffsetY.value = y;
+          }
+        },
+      });
+
     return {
       handleOnStart,
       handleOnActive,
       handleOnEnd,
+      animatedScrollHandler,
     };
   };
diff --git a/src/hooks/useGestureHandler.ts b/src/hooks/useGestureHandler.ts
index eb50e72be..7c16c5488 100644
--- a/src/hooks/useGestureHandler.ts
+++ b/src/hooks/useGestureHandler.ts
@@ -4,10 +4,7 @@ import {
   PanGestureHandlerGestureEvent,
 } from 'react-native-gesture-handler';
 import { GESTURE_SOURCE } from '../constants';
-import type {
-  GestureEventContextType,
-  GestureEventHandlerCallbackType,
-} from '../types';
+import type { GestureEventHandlerCallbackType } from '../types';
 
 const resetContext = (context: any) => {
   'worklet';
@@ -17,6 +14,10 @@ const resetContext = (context: any) => {
   });
 };
 
+type GestureEventContextType = {
+  didStart?: boolean;
+};
+
 export const useGestureHandler = (
   type: GESTURE_SOURCE,
   state: Animated.SharedValue<State>,
diff --git a/src/hooks/useNormalizedSnapPoints.ts b/src/hooks/useNormalizedSnapPoints.ts
index 872b2f8bd..a10d7450e 100644
--- a/src/hooks/useNormalizedSnapPoints.ts
+++ b/src/hooks/useNormalizedSnapPoints.ts
@@ -1,4 +1,7 @@
-import Animated, { useDerivedValue } from 'react-native-reanimated';
+import Animated, {
+  isSharedValue,
+  useDerivedValue,
+} from 'react-native-reanimated';
 import { normalizeSnapPoint } from '../utilities';
 import type { BottomSheetProps } from '../components/bottomSheet';
 import {
@@ -35,7 +38,7 @@ export const useNormalizedSnapPoints = (
     }
 
     const _snapPoints = snapPoints
-      ? 'value' in snapPoints
+      ? isSharedValue(snapPoints)
         ? snapPoints.value
         : snapPoints
       : [];
diff --git a/src/hooks/usePropsValidator.ts b/src/hooks/usePropsValidator.ts
index 09c0b0028..8a2d275b0 100644
--- a/src/hooks/usePropsValidator.ts
+++ b/src/hooks/usePropsValidator.ts
@@ -2,6 +2,7 @@ import { useMemo } from 'react';
 import invariant from 'invariant';
 import { INITIAL_SNAP_POINT } from '../components/bottomSheet/constants';
 import type { BottomSheetProps } from '../components/bottomSheet';
+import { isSharedValue } from 'react-native-reanimated';
 
 /**
  * @todo
@@ -18,7 +19,7 @@ export const usePropsValidator = ({
   useMemo(() => {
     //#region snap points
     const _snapPoints = snapPoints
-      ? 'value' in snapPoints
+      ? isSharedValue(snapPoints)
         ? snapPoints.value
         : snapPoints
       : [];
@@ -40,7 +41,9 @@ export const usePropsValidator = ({
     });
 
     invariant(
-      'value' in _snapPoints || _snapPoints.length > 0 || enableDynamicSizing,
+      isSharedValue(_snapPoints) ||
+        _snapPoints.length > 0 ||
+        enableDynamicSizing,
       `'snapPoints' was provided with no points! please provide at least one snap point.`
     );
     //#endregion
diff --git a/src/hooks/useReactiveSharedValue.ts b/src/hooks/useReactiveSharedValue.ts
index 05866c459..ec5af067e 100644
--- a/src/hooks/useReactiveSharedValue.ts
+++ b/src/hooks/useReactiveSharedValue.ts
@@ -1,6 +1,7 @@
 import { useEffect, useRef } from 'react';
 import Animated, {
   cancelAnimation,
+  isSharedValue,
   makeMutable,
 } from 'react-native-reanimated';
 import type { Primitive } from '../types';
@@ -11,7 +12,7 @@ export const useReactiveSharedValue = <T>(
   const initialValueRef = useRef<T>(null);
   const valueRef = useRef<Animated.SharedValue<T>>(null);
 
-  if (value && typeof value === 'object' && 'value' in value) {
+  if (isSharedValue(value)) {
     /**
      * if provided value is a shared value,
      * then we do not initialize another one.
diff --git a/src/hooks/useScrollEventsHandlersDefault.ts b/src/hooks/useScrollEventsHandlersDefault.ts
deleted file mode 100644
index 81cdaf6d6..000000000
--- a/src/hooks/useScrollEventsHandlersDefault.ts
+++ /dev/null
@@ -1,217 +0,0 @@
-import { scrollTo, useSharedValue, useWorkletCallback, useAnimatedReaction } from 'react-native-reanimated';
-import { useBottomSheetInternal } from './useBottomSheetInternal';
-import { ANIMATION_STATE, SCROLLABLE_STATE, SHEET_STATE } from '../constants';
-import type {
-  ScrollEventsHandlersHookType,
-  ScrollEventHandlerCallbackType,
-} from '../types';
-import { Platform } from 'react-native';
-
-export type ScrollEventContextType = {
-  initialContentOffsetY: number;
-  shouldLockInitialPosition: boolean;
-};
-
-export const useScrollEventsHandlersDefault: ScrollEventsHandlersHookType = (
-  scrollableRef,
-  scrollableContentOffsetY,
-  scrollBuffer,
-  preserveScrollMomentum,
-  lockableScrollableContentOffsetY,
-) => {
-  // hooks
-  const {
-    animatedSheetState,
-    animatedScrollableState,
-    animatedAnimationState,
-    animatedScrollableContentOffsetY: rootScrollableContentOffsetY,
-    isScrollableLocked,
-    isScrollEnded,
-  } = useBottomSheetInternal();
-  const awaitingFirstScroll = useSharedValue(false);
-  const _lockableScrollableContentOffsetY = useSharedValue(0);
-
-  useAnimatedReaction(
-    () => _lockableScrollableContentOffsetY.value,
-    _lockableScrollableContentOffsetY => {
-      if (lockableScrollableContentOffsetY) {
-        lockableScrollableContentOffsetY.value = _lockableScrollableContentOffsetY;
-      }
-    }
-  );
-
-  //#region callbacks
-  const handleOnScroll: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      (event, context) => {
-        /**
-         * When a scrollBuffer is provided, we take locking the scrollable into our own hands.
-         * We need to do this because it's not possible to know the direction of the scroll during
-         * handleOnBeginDrag, and the scrollable shouldn't be locked when scrolling back to the
-         * start of the list.
-         */
-        if ((preserveScrollMomentum || scrollBuffer) && awaitingFirstScroll.value && !isScrollableLocked.value) {
-          const isScrollingTowardsBottom = context.initialContentOffsetY < event.contentOffset.y;
-          if (isScrollingTowardsBottom && event.contentOffset.y > (scrollBuffer ?? 0) && context.shouldLockInitialPosition) {
-            isScrollableLocked.value = true;
-            animatedScrollableState.value = SCROLLABLE_STATE.LOCKED;
-          } else if (!isScrollingTowardsBottom && preserveScrollMomentum && event.contentOffset.y <= 0 && context.shouldLockInitialPosition) {
-            isScrollableLocked.value = true;
-            animatedScrollableState.value = SCROLLABLE_STATE.LOCKED;
-          }
-          awaitingFirstScroll.value = false;
-        }
-
-        /**
-         * if sheet position is extended or fill parent, then we reset
-         * `shouldLockInitialPosition` value to false.
-         */
-        if (
-          animatedSheetState.value === SHEET_STATE.EXTENDED ||
-          animatedSheetState.value === SHEET_STATE.FILL_PARENT
-        ) {
-          context.shouldLockInitialPosition = false;
-        }
-
-        if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
-          if (!(preserveScrollMomentum && isScrollEnded.value)) {
-            const lockPosition = context.shouldLockInitialPosition
-              ? context.initialContentOffsetY ?? 0
-              : 0;
-            // @ts-ignore
-            scrollTo(scrollableRef, 0, lockPosition, false);
-            scrollableContentOffsetY.value = lockPosition;
-            _lockableScrollableContentOffsetY.value = lockPosition;
-          }
-          return;
-        }
-        _lockableScrollableContentOffsetY.value = event.contentOffset.y;
-      },
-      [
-        scrollableRef,
-        scrollableContentOffsetY,
-        animatedScrollableState,
-        animatedSheetState,
-      ]
-    );
-  const handleOnBeginDrag: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      (event, context) => {
-        const y = event.contentOffset.y;
-        scrollableContentOffsetY.value = y;
-        _lockableScrollableContentOffsetY.value = y;
-        rootScrollableContentOffsetY.value = y;
-        context.initialContentOffsetY = y;
-        awaitingFirstScroll.value = true;
-        isScrollEnded.value = false;
-
-        if (scrollBuffer) {
-          if (y <= 0 && (
-            animatedSheetState.value === SHEET_STATE.EXTENDED ||
-            animatedSheetState.value === SHEET_STATE.FILL_PARENT
-          )) {
-            isScrollableLocked.value = true;
-          } else {
-            isScrollableLocked.value = false;
-          }
-        } else if (preserveScrollMomentum) {
-          if (Platform.OS === 'ios') {
-            isScrollableLocked.value = false;
-          } else {
-            // On Android, there is no overscroll, so the handleOnScroll
-            // callback never fires when dragging down from the top. In those cases,
-            // we just want to lock the scrollable immediately so that it can
-            // pan downward as expected.
-            isScrollableLocked.value = y <= 0;
-          }
-        } else {
-          isScrollableLocked.value = true;
-        }
-
-        /**
-         * if sheet position not extended or fill parent and the scrollable position
-         * not at the top, then we should lock the initial scrollable position.
-         */
-        if (
-          (animatedSheetState.value !== SHEET_STATE.EXTENDED &&
-          animatedSheetState.value !== SHEET_STATE.FILL_PARENT &&
-          y > 0) || (preserveScrollMomentum && y <= 0)
-        ) {
-          context.shouldLockInitialPosition = true;
-        } else {
-          context.shouldLockInitialPosition = false;
-        }
-      },
-      [
-        scrollableContentOffsetY,
-        animatedSheetState,
-        rootScrollableContentOffsetY,
-      ]
-    );
-  const handleOnEndDrag: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      ({ contentOffset: { y }}, context) => {
-        awaitingFirstScroll.value = false;
-        isScrollEnded.value = true;
-        if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
-          const lockPosition = context.shouldLockInitialPosition
-            ? context.initialContentOffsetY ?? 0
-            : 0;
-          // @ts-ignore
-          scrollTo(scrollableRef, 0, lockPosition, false);
-          scrollableContentOffsetY.value = lockPosition;
-          _lockableScrollableContentOffsetY.value = lockPosition;
-          return;
-        }
-        if (animatedAnimationState.value !== ANIMATION_STATE.RUNNING) {
-          scrollableContentOffsetY.value = y;
-          _lockableScrollableContentOffsetY.value = y;
-          rootScrollableContentOffsetY.value = y;
-        }
-      },
-      [
-        scrollableRef,
-        scrollableContentOffsetY,
-        animatedAnimationState,
-        animatedScrollableState,
-        rootScrollableContentOffsetY,
-      ]
-    );
-  const handleOnMomentumEnd: ScrollEventHandlerCallbackType<ScrollEventContextType> =
-    useWorkletCallback(
-      ({ contentOffset: { y } }, context) => {
-        if (animatedScrollableState.value === SCROLLABLE_STATE.LOCKED) {
-          if (!(preserveScrollMomentum && isScrollEnded.value)) {
-            const lockPosition = context.shouldLockInitialPosition
-              ? context.initialContentOffsetY ?? 0
-              : 0;
-            // @ts-ignore
-            scrollTo(scrollableRef, 0, lockPosition, false);
-            scrollableContentOffsetY.value = 0;
-            _lockableScrollableContentOffsetY.value = 0;
-          }
-          return;
-        }
-        if (animatedAnimationState.value !== ANIMATION_STATE.RUNNING) {
-          scrollableContentOffsetY.value = y;
-          _lockableScrollableContentOffsetY.value = y;
-          rootScrollableContentOffsetY.value = y;
-        }
-      },
-      [
-        scrollableContentOffsetY,
-        scrollableRef,
-        animatedAnimationState,
-        animatedScrollableState,
-        rootScrollableContentOffsetY,
-      ]
-    );
-  //#endregion
-
-  return {
-    handleOnScroll,
-    handleOnBeginDrag,
-    handleOnEndDrag,
-    handleOnMomentumEnd,
-  };
-};
diff --git a/src/hooks/useScrollHandler.ts b/src/hooks/useScrollHandler.ts
deleted file mode 100644
index 619ad803b..000000000
--- a/src/hooks/useScrollHandler.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import {
-  SharedValue,
-  runOnJS,
-  useAnimatedRef,
-  useAnimatedScrollHandler,
-  useSharedValue,
-} from 'react-native-reanimated';
-import { useScrollEventsHandlersDefault } from './useScrollEventsHandlersDefault';
-import { workletNoop as noop } from '../utilities';
-import type { Scrollable, ScrollableEvent } from '../types';
-
-export const useScrollHandler = (
-  useScrollEventsHandlers = useScrollEventsHandlersDefault,
-  onScroll?: ScrollableEvent,
-  onScrollBeginDrag?: ScrollableEvent,
-  onScrollEndDrag?: ScrollableEvent,
-  scrollBuffer?: number,
-  preserveScrollMomentum?: boolean,
-  lockableScrollableContentOffsetY?: SharedValue<number>,
-) => {
-  // refs
-  const scrollableRef = useAnimatedRef<Scrollable>();
-
-  // variables
-  const scrollableContentOffsetY = useSharedValue<number>(0);
-
-  // hooks
-  const {
-    handleOnScroll = noop,
-    handleOnBeginDrag = noop,
-    handleOnEndDrag = noop,
-    handleOnMomentumEnd = noop,
-    handleOnMomentumBegin = noop,
-  } = useScrollEventsHandlers(scrollableRef, scrollableContentOffsetY, scrollBuffer, preserveScrollMomentum, lockableScrollableContentOffsetY);
-
-  // callbacks
-  const scrollHandler = useAnimatedScrollHandler(
-    {
-      onScroll: (event, context) => {
-        handleOnScroll(event, context);
-
-        if (onScroll) {
-          runOnJS(onScroll)({ nativeEvent: event });
-        }
-      },
-      onBeginDrag: (event, context) => {
-        handleOnBeginDrag(event, context);
-
-        if (onScrollBeginDrag) {
-          runOnJS(onScrollBeginDrag)({ nativeEvent: event });
-        }
-      },
-      onEndDrag: (event, context) => {
-        handleOnEndDrag(event, context);
-
-        if (onScrollEndDrag) {
-          runOnJS(onScrollEndDrag)({ nativeEvent: event });
-        }
-      },
-      onMomentumBegin: handleOnMomentumBegin,
-      onMomentumEnd: handleOnMomentumEnd,
-    },
-    [
-      handleOnScroll,
-      handleOnBeginDrag,
-      handleOnEndDrag,
-      handleOnMomentumBegin,
-      handleOnMomentumEnd,
-      onScroll,
-      onScrollBeginDrag,
-      onScrollEndDrag,
-    ]
-  );
-
-  return { scrollHandler, scrollableRef, scrollableContentOffsetY };
-};
diff --git a/src/hooks/useScrollable.ts b/src/hooks/useScrollable.ts
index fe79e4df9..5be4cf447 100644
--- a/src/hooks/useScrollable.ts
+++ b/src/hooks/useScrollable.ts
@@ -1,14 +1,10 @@
-import { useCallback, RefObject, useRef } from 'react';
-import { findNodeHandle } from 'react-native';
-import { useSharedValue } from 'react-native-reanimated';
+import { useAnimatedRef, useSharedValue } from 'react-native-reanimated';
 import { SCROLLABLE_STATE, SCROLLABLE_TYPE } from '../constants';
-import type { ScrollableRef, Scrollable } from '../types';
+import type { Scrollable } from '../types';
 
 export const useScrollable = () => {
   // refs
-  const scrollableRef = useRef<ScrollableRef>(null);
-  const previousScrollableRef = useRef<ScrollableRef>(null);
-
+  const scrollableRef = useAnimatedRef<Scrollable>();
   // variables
   const animatedScrollableType = useSharedValue<SCROLLABLE_TYPE>(
     SCROLLABLE_TYPE.UNDETERMINED
@@ -21,44 +17,6 @@ export const useScrollable = () => {
   const isScrollableLocked = useSharedValue<boolean>(true);
   const isScrollEnded = useSharedValue<boolean>(true);
 
-  // callbacks
-  const setScrollableRef = useCallback((ref: ScrollableRef) => {
-    // get current node handle id
-    let currentRefId = scrollableRef.current?.id ?? null;
-
-    if (currentRefId !== ref.id) {
-      if (scrollableRef.current) {
-        // @ts-ignore
-        previousScrollableRef.current = scrollableRef.current;
-      }
-      // @ts-ignore
-      scrollableRef.current = ref;
-    }
-  }, []);
-
-  const removeScrollableRef = useCallback((ref: RefObject<Scrollable>) => {
-    // find node handle id
-    let id;
-    try {
-      id = findNodeHandle(ref.current);
-    } catch {
-      return;
-    }
-
-    // get current node handle id
-    let currentRefId = scrollableRef.current?.id ?? null;
-
-    /**
-     * @DEV
-     * when the incoming node is actually the current node, we reset
-     * the current scrollable ref to the previous one.
-     */
-    if (id === currentRefId) {
-      // @ts-ignore
-      scrollableRef.current = previousScrollableRef.current;
-    }
-  }, []);
-
   return {
     scrollableRef,
     animatedScrollableType,
@@ -67,7 +25,5 @@ export const useScrollable = () => {
     isScrollableRefreshable,
     isScrollableLocked,
     isScrollEnded,
-    setScrollableRef,
-    removeScrollableRef,
   };
 };
diff --git a/src/hooks/useScrollableSetter.ts b/src/hooks/useScrollableSetter.ts
index 711a1d13e..d5a0d04da 100644
--- a/src/hooks/useScrollableSetter.ts
+++ b/src/hooks/useScrollableSetter.ts
@@ -1,12 +1,10 @@
-import React, { useCallback, useEffect } from 'react';
+import { useCallback, useEffect } from 'react';
 import type Animated from 'react-native-reanimated';
 import { useBottomSheetInternal } from './useBottomSheetInternal';
 import type { SCROLLABLE_TYPE } from '../constants';
-import type { Scrollable } from '../types';
-import { Platform, findNodeHandle } from 'react-native';
+import { Platform } from 'react-native';
 
 export const useScrollableSetter = (
-  ref: React.RefObject<Scrollable>,
   type: SCROLLABLE_TYPE,
   contentOffsetY: Animated.SharedValue<number>,
   refreshable: boolean,
@@ -17,12 +15,10 @@ export const useScrollableSetter = (
   // hooks
   const {
     animatedScrollableType,
-    animatedScrollableContentOffsetY: rootScrollableContentOffsetY,
+    animatedScrollableContentOffsetY,
     isContentHeightFixed,
     isScrollableRefreshable,
     isScrollableLocked,
-    setScrollableRef,
-    removeScrollableRef,
     animatedContainerHeight,
     animatedContentHeight,
     isScrollEnded,
@@ -31,40 +27,26 @@ export const useScrollableSetter = (
   // callbacks
   const handleSettingScrollable = useCallback(() => {
     // set current content offset
-    rootScrollableContentOffsetY.value = contentOffsetY.value;
+    animatedScrollableContentOffsetY.value = contentOffsetY.value;
     animatedScrollableType.value = type;
     isScrollableRefreshable.value = refreshable;
     // Keep isScrollableLocked value if the scrollable is still scrolling
     // Android scrollview doesn't bounce so we need to set isScrollableLocked so that the sheet can be pulled up/down
-    isScrollableLocked.value = (!isScrollEnded.value && isScrollableLocked.value) || (!preserveScrollMomentum && !scrollBuffer) || (Platform.OS === 'android' && animatedContentHeight.value <= animatedContainerHeight.value);
+    isScrollableLocked.value =
+      (!isScrollEnded.value && isScrollableLocked.value) ||
+      (!preserveScrollMomentum && !scrollBuffer) ||
+      (Platform.OS === 'android' &&
+        animatedContentHeight.value <= animatedContainerHeight.value);
     isContentHeightFixed.value = false;
-
-    // set current scrollable ref
-    const id = findNodeHandle(ref.current);
-    if (id) {
-      setScrollableRef({
-        id: id,
-        node: ref,
-      });
-    } else {
-      console.warn(`Couldn't find the scrollable node handle id!`);
-    }
-
-    return () => {
-      removeScrollableRef(ref);
-    };
   }, [
-    ref,
     type,
     refreshable,
     animatedScrollableType,
-    rootScrollableContentOffsetY,
+    animatedScrollableContentOffsetY,
     contentOffsetY,
     isScrollableRefreshable,
     isScrollableLocked,
     isContentHeightFixed,
-    setScrollableRef,
-    removeScrollableRef,
   ]);
 
   // effects
diff --git a/src/index.ts b/src/index.ts
index b2564870a..a14bd1435 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -13,10 +13,8 @@ export { useBottomSheetTimingConfigs } from './hooks/useBottomSheetTimingConfigs
 export { useBottomSheetInternal } from './hooks/useBottomSheetInternal';
 export { useBottomSheetModalInternal } from './hooks/useBottomSheetModalInternal';
 export { useBottomSheetDynamicSnapPoints } from './hooks/useBottomSheetDynamicSnapPoints';
-export { useScrollEventsHandlersDefault } from './hooks/useScrollEventsHandlersDefault';
 export { useGestureEventsHandlersDefault } from './hooks/useGestureEventsHandlersDefault';
 export { useBottomSheetGestureHandlers } from './hooks/useBottomSheetGestureHandlers';
-export { useScrollHandler } from './hooks/useScrollHandler';
 export { useScrollableSetter } from './hooks/useScrollableSetter';
 //#endregion
 
@@ -63,9 +61,7 @@ export type {
 } from './components/bottomSheetScrollable';
 
 export type {
-  ScrollEventsHandlersHookType,
   GestureEventsHandlersHookType,
-  ScrollEventHandlerCallbackType,
   GestureEventHandlerCallbackType,
 } from './types';
 //#endregion
diff --git a/src/types.d.ts b/src/types.d.ts
index a7cd4fe19..47d9fcbda 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -1,4 +1,3 @@
-import type React from 'react';
 import type {
   FlatList,
   ScrollView,
@@ -17,7 +16,7 @@ import type {
   WithTimingConfig,
 } from 'react-native-reanimated';
 import type { FlashList } from '@shopify/flash-list';
-import type { GESTURE_SOURCE } from './constants';
+import { type GESTURE_SOURCE, KEYBOARD_STATE } from './constants';
 
 //#region Methods
 export interface BottomSheetMethods {
@@ -110,10 +109,6 @@ export interface BottomSheetVariables {
 
 //#region scrollables
 export type Scrollable = FlashList | FlatList | ScrollView | SectionList;
-export type ScrollableRef = {
-  id: number;
-  node: React.RefObject<Scrollable>;
-};
 export type ScrollableEvent = (
   event: Pick<NativeSyntheticEvent<NativeScrollEvent>, 'nativeEvent'>
 ) => void;
@@ -130,11 +125,20 @@ export interface Insets {
 //#endregion
 
 //#region hooks
-export type GestureEventPayloadType = GestureEventPayload &
-  PanGestureHandlerEventPayload;
+export type GestureEventPayloadType = Pick<
+  GestureEventPayload & PanGestureHandlerEventPayload,
+  'absoluteY' | 'translationY' | 'velocityY'
+>;
+
+export type PanGestureEventContextType = {
+  initialPosition: number;
+  initialKeyboardState: KEYBOARD_STATE;
+  isScrollablePositionLocked: boolean;
+};
 
-export type GestureEventContextType = {
-  didStart?: boolean;
+export type ScrollEventContextType = {
+  initialContentOffsetY: number | undefined;
+  shouldLockInitialPosition: boolean;
 };
 
 export type GestureEventHandlerCallbackType<C = any> = (
@@ -147,25 +151,7 @@ export type GestureEventsHandlersHookType = () => {
   handleOnStart: GestureEventHandlerCallbackType;
   handleOnActive: GestureEventHandlerCallbackType;
   handleOnEnd: GestureEventHandlerCallbackType;
-};
-
-type ScrollEventHandlerCallbackType<C = any> = (
-  payload: NativeScrollEvent,
-  context: C
-) => void;
-
-export type ScrollEventsHandlersHookType = (
-  ref: React.RefObject<Scrollable>,
-  contentOffsetY: SharedValue<number>,
-  scrollBuffer: number | undefined,
-  preserveScrollMomentum: boolean | undefined,
-  lockableScrollableContentOffsetY: SharedValue<number> | undefined
-) => {
-  handleOnScroll?: ScrollEventHandlerCallbackType;
-  handleOnBeginDrag?: ScrollEventHandlerCallbackType;
-  handleOnEndDrag?: ScrollEventHandlerCallbackType;
-  handleOnMomentumBegin?: ScrollEventHandlerCallbackType;
-  handleOnMomentumEnd?: ScrollEventHandlerCallbackType;
+  animatedScrollHandler: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
 };
 //#endregion