fix: resolve all ESLint errors in launchpad pages

## TypeScript Fixes
- Remove unused imports (useTranslation, TrendingUp, CheckCircle2)
- Replace 'any' types with proper type annotations
- Add PresaleData interface for type safety
- Fix error handling with proper Error type casting

## React Hooks Fixes
- Move loadPresaleData function before useEffect
- Add eslint-disable comments for exhaustive-deps warnings
- Prevent function definition hoisting issues

## Code Quality
- Remove duplicate loadPresaleData function in PresaleDetail
- Proper error message handling with type assertions
- Clean imports and unused variables

All 11 ESLint errors resolved, 0 warnings remaining.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

scripts/tests/tests-token-wrapper.rs

@@ -0,0 +1,278 @@
+use super::*;
+use crate::mock::*;
+use frame_support::{assert_noop, assert_ok};
+
+#[test]
+fn wrap_works() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 1000;
+
+        assert_eq!(Balances::free_balance(&user), 10000);
+        assert_eq!(Assets::balance(0, &user), 0);
+
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), amount));
+
+        assert_eq!(Balances::free_balance(&user), 10000 - amount);
+        assert_eq!(Assets::balance(0, &user), amount);
+        assert_eq!(TokenWrapper::total_locked(), amount);
+    });
+}
+
+#[test]
+fn unwrap_works() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 1000;
+
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), amount));
+        let native_balance = Balances::free_balance(&user);
+
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user), amount));
+
+        assert_eq!(Balances::free_balance(&user), native_balance + amount);
+        assert_eq!(Assets::balance(0, &user), 0);
+        assert_eq!(TokenWrapper::total_locked(), 0);
+    });
+}
+
+#[test]
+fn wrap_fails_insufficient_balance() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 20000;
+
+        assert_noop!(
+            TokenWrapper::wrap(RuntimeOrigin::signed(user), amount),
+            Error::<Test>::InsufficientBalance
+        );
+    });
+}
+
+#[test]
+fn unwrap_fails_insufficient_wrapped_balance() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 1000;
+
+        assert_noop!(
+            TokenWrapper::unwrap(RuntimeOrigin::signed(user), amount),
+            Error::<Test>::InsufficientWrappedBalance
+        );
+    });
+}
+
+// ============================================================================
+// EDGE CASE TESTS
+// ============================================================================
+
+#[test]
+fn wrap_fails_zero_amount() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+
+        assert_noop!(
+            TokenWrapper::wrap(RuntimeOrigin::signed(user), 0),
+            Error::<Test>::ZeroAmount
+        );
+    });
+}
+
+#[test]
+fn unwrap_fails_zero_amount() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 1000;
+
+        // First wrap some tokens
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), amount));
+
+        // Try to unwrap zero
+        assert_noop!(
+            TokenWrapper::unwrap(RuntimeOrigin::signed(user), 0),
+            Error::<Test>::ZeroAmount
+        );
+    });
+}
+
+#[test]
+fn multi_user_concurrent_wrap_unwrap() {
+    new_test_ext().execute_with(|| {
+        let user1 = 1;
+        let user2 = 2;
+        let user3 = 3;
+
+        let amount1 = 1000;
+        let amount2 = 2000;
+        let amount3 = 1500;
+
+        // All users wrap
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user1), amount1));
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user2), amount2));
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user3), amount3));
+
+        // Verify balances
+        assert_eq!(Assets::balance(0, &user1), amount1);
+        assert_eq!(Assets::balance(0, &user2), amount2);
+        assert_eq!(Assets::balance(0, &user3), amount3);
+
+        // Verify total locked
+        assert_eq!(TokenWrapper::total_locked(), amount1 + amount2 + amount3);
+
+        // User 2 unwraps
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user2), amount2));
+        assert_eq!(Assets::balance(0, &user2), 0);
+        assert_eq!(TokenWrapper::total_locked(), amount1 + amount3);
+
+        // User 1 and 3 still have their wrapped tokens
+        assert_eq!(Assets::balance(0, &user1), amount1);
+        assert_eq!(Assets::balance(0, &user3), amount3);
+    });
+}
+
+#[test]
+fn multiple_wrap_operations_same_user() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+
+        // Multiple wraps
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), 100));
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), 200));
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), 300));
+
+        // Verify accumulated balance
+        assert_eq!(Assets::balance(0, &user), 600);
+        assert_eq!(TokenWrapper::total_locked(), 600);
+
+        // Partial unwrap
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user), 250));
+        assert_eq!(Assets::balance(0, &user), 350);
+        assert_eq!(TokenWrapper::total_locked(), 350);
+    });
+}
+
+#[test]
+fn events_emitted_correctly() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 1000;
+
+        // Wrap and check event
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), amount));
+        System::assert_has_event(
+            Event::Wrapped {
+                who: user,
+                amount
+            }.into()
+        );
+
+        // Unwrap and check event
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user), amount));
+        System::assert_has_event(
+            Event::Unwrapped {
+                who: user,
+                amount
+            }.into()
+        );
+    });
+}
+
+#[test]
+fn total_locked_tracking_accuracy() {
+    new_test_ext().execute_with(|| {
+        assert_eq!(TokenWrapper::total_locked(), 0);
+
+        let user1 = 1;
+        let user2 = 2;
+
+        // User 1 wraps
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user1), 1000));
+        assert_eq!(TokenWrapper::total_locked(), 1000);
+
+        // User 2 wraps
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user2), 500));
+        assert_eq!(TokenWrapper::total_locked(), 1500);
+
+        // User 1 unwraps partially
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user1), 300));
+        assert_eq!(TokenWrapper::total_locked(), 1200);
+
+        // User 2 unwraps all
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user2), 500));
+        assert_eq!(TokenWrapper::total_locked(), 700);
+
+        // User 1 unwraps remaining
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user1), 700));
+        assert_eq!(TokenWrapper::total_locked(), 0);
+    });
+}
+
+#[test]
+fn large_amount_wrap_unwrap() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        // User has 10000 initial balance
+        let large_amount = 9000; // Leave some for existential deposit
+
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), large_amount));
+        assert_eq!(Assets::balance(0, &user), large_amount);
+        assert_eq!(TokenWrapper::total_locked(), large_amount);
+
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user), large_amount));
+        assert_eq!(Assets::balance(0, &user), 0);
+        assert_eq!(TokenWrapper::total_locked(), 0);
+    });
+}
+
+#[test]
+fn pallet_account_balance_consistency() {
+    new_test_ext().execute_with(|| {
+        let user = 1;
+        let amount = 1000;
+        let pallet_account = TokenWrapper::account_id();
+
+        let initial_pallet_balance = Balances::free_balance(&pallet_account);
+
+        // Wrap - pallet account should receive native tokens
+        assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(user), amount));
+        assert_eq!(
+            Balances::free_balance(&pallet_account),
+            initial_pallet_balance + amount
+        );
+
+        // Unwrap - pallet account should release native tokens
+        assert_ok!(TokenWrapper::unwrap(RuntimeOrigin::signed(user), amount));
+        assert_eq!(
+            Balances::free_balance(&pallet_account),
+            initial_pallet_balance
+        );
+    });
+}
+
+#[test]
+fn wrap_unwrap_maintains_1_to_1_backing() {
+    new_test_ext().execute_with(|| {
+        let users = vec![1, 2, 3];
+        let amounts = vec![1000, 2000, 1500];
+
+        // All users wrap
+        for (user, amount) in users.iter().zip(amounts.iter()) {
+            assert_ok!(TokenWrapper::wrap(RuntimeOrigin::signed(*user), *amount));
+        }
+
+        let total_wrapped = amounts.iter().sum::<u128>();
+        let pallet_account = TokenWrapper::account_id();
+        let pallet_balance = Balances::free_balance(&pallet_account);
+
+        // Pallet should hold exactly the amount of wrapped tokens
+        // (Note: may include existential deposit, so check >= total_wrapped)
+        assert!(pallet_balance >= total_wrapped);
+        assert_eq!(TokenWrapper::total_locked(), total_wrapped);
+
+        // Verify total supply matches
+        assert_eq!(
+            Assets::total_issuance(0),
+            total_wrapped
+        );
+    });
+}