The problem Startum Wallet solves

The Problem It Solves
Most crypto wallets are built for technical users, not everyday people.
Sending funds can be stressful due to long addresses, irreversible transactions, and unclear confirmation steps.
Security often depends on a single device and weak user habits.
Seed phrase handling is confusing, and mistakes can lead to permanent asset loss.
For merchants and small businesses, accepting crypto in person is still fragmented and hard to operationalize.
What People Can Use Startum For
Personal payments: Send and receive crypto with a guided flow that reduces mistakes.
In-person transactions: Accept payments via QR or NFC in retail/pop-up/storefront contexts.
Safer signing: Require both app interaction and NFC card presence for sensitive actions.
Daily wallet management: Track balances, recent activity, and transaction status in one place.
Fast payment requests: Create amount-based receive requests using built-in numpad + QR/NFC modes.
How It Makes Existing Tasks Easier
Converts complex crypto actions into step-by-step guided flows.
Reduces copy-paste/address errors with cleaner input and confirmation UX.
Shows clear states (pending, success, failure) so users know exactly what happened.
Improves merchant flow with immediate “payment received” feedback.
Lowers onboarding friction with structured setup and clear security prompts.
How It Makes Existing Tasks Safer
Adds a physical trust layer using NFC card interaction.
Uses confirmation checkpoints before final transaction submission.
Encourages stronger operational security through setup and verification steps.
Reduces accidental actions by separating selection, authorization, and confirmation.
Keeps a self-custody-first approach while making secure behavior more user-friendly.

Challenges we ran into

Challenges I Ran Into

1. Module import path breakages after moving to new onboarding structure
   What happened:
   When I split onboarding into dedicated screens and folders, some relative imports pointed to the wrong directories, which caused compile errors.

How I fixed it:

Corrected import paths for theme and shared UI components in onboarding screens.
Re-ran diagnostics on affected files to confirm no unresolved modules remained.
Outcome:
Build errors were removed and the onboarding flow compiled cleanly.

2. Clipboard API mismatch in React Native flow
   What happened:
   Copy/paste actions used the old React Native clipboard API, which is no longer the recommended approach in modern Expo setups.

How I fixed it:

Migrated copy/paste logic to Expo Clipboard.
Updated both reusable UI components and screen-level handlers using clipboard actions.
Outcome:
Copy address and paste recipient features worked consistently and passed type checks.

3. Missing icon dependency/type resolution
   What happened:
   Icon imports failed with type/module resolution errors during diagnostics.

How I fixed it:

Added the vector icons package explicitly to dependencies.
Installed related package updates through Expo-compatible install commands.
Outcome:
Icon-related compile/type issues were resolved across wallet, pay, receive, and settings screens.

4. Data shape mismatch in activity transaction list
   What happened:
   The activity screen passed props that did not match the transaction row component contract (field names and timestamp type mismatches).

How I fixed it:

Normalized mock data structure to match expected props.
Converted timestamps into compatible date string format.
Added an empty state for filtered results.
Outcome:
Activity screen rendered correctly and no longer threw prop/type errors.

5. APK build and artifact management
   What happened:
   Release build logs were noisy with Gradle warnings, and the generated APK was nested deep in Android output folders.

How I fixed it:

Completed a full release build using Gradle assembleRelease.
Verified build success and manually copied the APK to the repository root for easy access.
Outcome:
A production release APK was generated successfully and made easy to locate for sharing/testing.

Key Lesson
The biggest wins came from running diagnostics frequently, fixing integration issues in small batches, and validating each layer (dependencies, paths, component props, build output) before moving to the next feature.