Core
Info
Core is the foundation of DARCA: a unified layer of money, statuses, security, and support. It always works, while expanded capabilities are delivered through modules - without overload and without fragmentation.
Separation Logic: Core and Modules
The functionality is split into a stable core and attachable modules, so the product can scale without chaos in UX and infrastructure.
DARCA is built as a platform where the Core is responsible for the “baseline” - daily operations, clear statuses, security, and support. This is the layer that remains unified when entering new markets and when adding new directions.
Modules are extensions that add powerful verticals (for example, trading or investment), specific rails, regional requirements, or advanced features. They are layered on top of the core and follow its rules: unified statuses, notifications, risk control, and user experience.
Tip
This approach makes it possible to add new directions “on top” of the system without turning the application into a set of disconnected services and interfaces.
How It Works in Practice
The Core is enabled by default, while modules are activated selectively - depending on the market, the user profile, and the available scenarios.
At the foundation there is always one layer: asset balances, fund movements, confirmations, history, notifications, and support. The user experiences a single product, not a “showcase of different applications”.
Modules are added when the relevant scenarios appear: regional requirements, the chosen level of capabilities, the need for new tools, or separate product directions. At the same time, they do not duplicate the baseline elements - they extend them.
Example
If an investment scenario is needed, a module is enabled, but sending, confirmation, status, notifications, and history remain in the Core and look the same across all scenarios.
What’s Included in the Core
The Core covers everyday financial actions: from login and balances to transfers, exchange, notifications, support, and baseline security.
- Account, login, and DARCA ID as a single identity across the ecosystem.
- Unified balances and wallets: fiat and crypto in one interface, with a single transaction history.
- Instant internal transfers with no fees: via phone number, contacts, or email, without “long addresses”.
- External transfers as a baseline layer: transparent terms before confirmation, with protection against user errors.
- Instant exchange: “what I give / what I receive / terms / final result” with alerts for favorable rates.
- Payments for everyday scenarios: service payments and autopayments, reserving funds for a goal and timeframe.
- Notifications and financial clarity: statuses, warnings, analytics, and periodic reports.
- In-app support: chat on any page, quick actions via buttons and deep links, an AI layer for speed and accuracy.
- Security by default: 2FA/biometrics, session control, alerts for logins and critical actions, baseline limits and anti-fraud rules.
Warning
Any critical actions must be confirmed by the user in the product: support can assist and accelerate the process, but does not “execute transactions on behalf of the user”.
What Belongs to the Modules
Modules add “power” verticals and specialized scenarios, preserving the Core’s unified rules and avoiding overload of the baseline experience.
Modules are what does not have to exist for every user “from day one”, but must be instantly available when a need arises. They expand capabilities while staying within the same principles of statuses, confirmations, and support.
- P2P and trading tools: deals, analytics, notifications, automated scenarios.
- RWA directions and products related to assets and fractional ownership.
- NFT and a new type of digital assets.
- Yield: staking and other mechanics (where appropriate and permitted).
- Mining and infrastructure scenarios (if included in a specific product version).
- Messenger features with financial actions (transfers, debts, collections in chat).
- Enhanced security: strengthened protection modes, additional confirmations and access layers.
- Cold storage and “vault” modes.
Question
How are modules enabled? They are activated selectively - by market, profile, and scenario - and immediately use the unified Core layer: statuses, history, notifications, and support.
Principles the Core Always Guarantees
Regardless of which modules are enabled, the Core maintains unified rules of transparency, predictability and security.
DARCA looks and feels like a single system because the foundational principles do not change from one scenario to another.
- Transparent terms before confirmation: the user sees the final outcome in advance and understands what will happen next.
- Predictable statuses: every operation has a clear lifecycle and precise notifications.
- Unified support: context is not lost, resolution does not turn into endless back-and-forth, but is carried through to a result.
- Security-by-default: critical actions require confirmation, access and sessions are controlled.
- Unified UX: fiat and crypto exist within one framework, and modules expand capabilities without breaking the interface or logic.
Note
The Core is what makes the product “recognizable” in any market: one experience, one language of statuses, one security perimeter and one model of trust.
User Journey Within the Core
The Core is revealed through the user journey: from registration and first actions to everyday scenarios where speed, transparency, and support operate as one unified system.
This section describes what a person sees “from the very first screen”: how an account is created, how protection is enabled, which functions are available immediately and how new capabilities gradually unlock through KYC and an expansion of trust.
Note
Registration is available in most countries, except jurisdictions with restrictions; access to features depends on local requirements and verification checks.
Registration
Registration takes minutes: phone → SMS code → password → local PIN → biometrics, after which the basic crypto layer is immediately available.
How an Account Is Created
The entry barrier is extremely low: to start using DARCA, a phone number and a few security steps are enough. This enables a fast start without sacrificing safety - critical actions remain under the user’s control.
- Entering a phone number and confirming via a 6-digit code from SMS (One-time_password).
- Creating a password: at the start, we provide reliability recommendations without “punitive” requirements.
- Creating a PIN code (Personal_identification_number) - stored only locally on the device and reset upon logout.
- Enabling biometrics (Biometrics) - the primary confirmation method; if biometrics are unavailable, the PIN is used.
Tip
The PIN keypad is shuffled every time: even if someone observes finger movements, repeating the input becomes significantly harder.
Auto-Lock and “Live” Confirmation
After 180 seconds of inactivity, the app requests biometrics or PIN. This is not a “formality”, but a built-in barrier against accidental access - especially in public places and during brief distractions.
- Biometrics - the primary confirmation scenario.
- PIN - the fallback scenario when biometrics fail.
- The password is used for login and recovery, not for constant everyday confirmation.
Warning
Confirmation is enabled automatically and does not depend on the user’s “preference” - this is baseline Core protection. Configurable flexibility around timeouts appears in the security module.
Protection Against SIM Swap and Disposable Accounts
SMS remains part of registration, but trust in the phone number is not considered “absolute”. We use additional risk signals and protective modes to reduce threats such as SIM_swap_scam without slowing down entry.
- Binding the account to the device (device binding) as a baseline security layer.
- Limiting the frequency of attempts and code requests (Rate_limiting).
- Protective mode when risk signals appear (device change/suspicious activity): restrictions on critical actions until trust is confirmed.
Danger
Access recovery is not built solely on SMS: critical scenarios always require strengthened confirmation, so the phone number does not become a single point of compromise.
What Is Available Immediately After Registration
Right after registration, DARCA already functions as the fastest and most intuitive crypto wallet: the user can begin receiving and sending cryptocurrency without waiting for lengthy procedures. At the same time, functionality expands as the user completes KYC and enables additional modules.
Available immediately:
- Opening cryptocurrency accounts (wallets) and receiving funds.
- External transactions in baseline mode with risk-based restrictions (limits/delays/step-up confirmations when necessary).
- Instant internal transfers via phone, email, or internal address - with no internal fees, but with a free-usage limit.
- Access to DARCA Academy for learning (no bonuses granted until KYC).
- Access to a referral link: invitations are available immediately, rewards accumulate and unlock after KYC.
Example
A user registers, receives crypto into a wallet, sends internally by phone number - and already feels the Core’s speed. Then they see which limits and functions will unlock after KYC.
Micro-Learning and Gradual Expansion of Trust
Immediately after registration, a short onboarding is activated for the functions available “here and now”: it reduces mistakes (network, address, network fee) and makes first actions safer.
After that, DARCA does not require the user to “complete everything at once”, but expands the profile gradually - only where it brings direct value to the user:
- Email as a backup channel for important notifications and recovery.
- Connecting messengers as a notification channel (optional).
- Name and date of birth - to accelerate future verification and access setup.
Each step can be skipped, and progress is saved: when the user is ready to complete KYC, most data is already filled in, making the process shorter.
Question
Why is this convenient? Because advanced features unlock quickly, without a “20-minute questionnaire” and the user clearly understands in advance what they gain from the next step.
After KYC and Contract Signing
After KYC, the Core becomes a full financial framework: fiat, cards, payments, exchange and documents appear - while the set of available capabilities depends on the region and local requirements.
At this stage, DARCA stops being “just a crypto wallet” and becomes a unified place for money: crypto and fiat coexist within one experience, with the same statuses, one history and one support layer. This directly eliminates fragmentation and reduces the number of errors that usually end in long support conversations.
Info
Availability of specific features (fiat rails, cards, payments, documents) depends on the country, providers, and local requirements - the Core includes only what is permitted in the user’s region.
Fiat Accounts and Everyday Operations
A fiat layer appears: accounts, balances, and operations with Fiat_money. The user receives the familiar “banking” component, but without a split between crypto and fiat.
The market effect is simple: instead of three apps and manual “bridges” between them - one interface and predictable statuses. This solves the pain of outdated IT and weak mobile banking: everything works in one product, without “sticking points” or unclear steps.
Tip
The same status and history logic for fiat and crypto reduces anxiety: an operation does not “disappear”, but always remains within a clear lifecycle.
Cards: Virtual and Physical
After contract signing, card issuance becomes available: a virtual card for an instant start, and a physical card where delivery is available. The card is a bridge into offline and everyday scenarios.
The market benefit: crypto stops being an “asset for later” and becomes a tool for daily use. This strengthens retention and makes the product feel familiar - like a bank, but faster and more flexible.
Note
The card is part of the Core: payment history, statuses, notifications, and transaction documents are displayed as transparently as any other actions.
A Card Linked to a Crypto Account
A user can issue a card that is linked to any crypto account as the funding source. At the moment of payment, the required amount of crypto is automatically converted into fiat and the payment is processed through fiat infrastructure - the user pays “as usual”, but uses a crypto balance.
This immediately resolves two key market pains: fragmentation (no need to exchange and withdraw separately) and the sense of hidden fees (terms and deduction logic are described transparently, and the result is recorded in history).
Note
No separate in-app confirmation is required for card payments: after the transaction, the user instantly receives a notification and sees the deduction (crypto) and the final outcome (fiat) in the history.
Instant Exchange Within a Single Framework
After KYC, exchange works in full: crypto↔crypto and crypto↔fiat in one interface, with a clear calculation of “what I give / what I receive / final result”. This is not a separate service - it is part of the Core money engine.
The market appeal here lies in frequency: exchange is one of the most repeated scenarios. When it is embedded into the Core, unnecessary navigation and “trips to exchanges/exchangers” disappear, which reduces friction and increases daily usage.
Example
A user receives crypto → exchanges part of it into fiat → pays for services with a card - all in one chain, without breaking into third-party apps.
Service Payments and Recurring Transactions
After KYC, the payments block becomes available: mobile, internet, utilities, and other recurring scenarios, including autopayments. Where available, mandatory payments such as fines and government charges are added as well.
This directly solves the problem of “crypto is inconvenient in everyday life”. When payments are built in, the product stops being “a wallet for transfers” and becomes a daily financial hub - the kind of role traditional banks retain for years.
Tip
Autopayments and planning remove a typical pain point: “forgot to pay / missed a deadline / wasted time”, making the experience stable and predictable.
Subscriptions and Access Levels
After KYC, subscriptions and access tiers become available under the Subscription_business_model. A subscription defines platform-wide rights and limits: within the Core and across enabled modules - through one clear set of terms.
This is not a “paywall”, but a managed access system: the user clearly understands what unlocks at each level and the platform can more easily control risk and protect against disposable accounts.
Tip
A subscription governs entitlements: what is allowed, which limits apply, and which functions are available - without changing the baseline UX.
Trust Rating and Smart Restrictions
After KYC, a full trust rating/level appears: access to scenarios and restrictions are managed based on risk-based logic and the principles of Risk_management. This makes it possible to give freedom to “good” users while automatically containing suspicious cases.
The market effect: fewer abuses, fewer “blind” lockouts, fewer conflicts with support. And most importantly - fewer situations where security becomes an inconvenience for the majority.
Warning
Restrictions should feel like protection, not punishment: the system explains the reason and shows what is required to lift the restriction.
Documents, Statements and Reports
After KYC, the full documentation layer becomes available: statements, invoices, certificates, transaction reports and exports “for accounting/tax authorities” where applicable. Plus - a unified activity log and an Audit_trail for transparency.
This solves a key market trust problem: when a product can provide documents and reports, it stops being a “gray zone” and becomes a financial tool that is convenient to use legally and systematically.
Info
Documents are not an “add-on”, but the foundation of transparency: the user can always explain the origin of funds and present transaction history in a clear format.
Full-Level Support: How It Works
After KYC, support becomes not “information”, but action. The in-app chat is a management interface: it understands the request, provides a short answer and immediately offers the next step through buttons and deep links, so the user reaches the outcome in 1–2 clicks.
- If a user asks “how to send”, the chat does not explain abstractly - it guides step by step and ends with a “Go to transfer” button.
- If a document is needed, the chat generates the request and provides a “Download statement / invoice / certificate” button.
- The first layer is AI, escalation to an operator is enabled for critical cases and non-standard situations.
Danger
No phone calls: any “calls from DARCA” are considered fraud. All confirmations are performed only inside the application.
Additional Core Functions
These functions make the Core “alive”: it does not just execute operations, but prevents mistakes, builds habits and reduces experience fragmentation.
Predicting a shortage of funds
The Core can do more than show the current balance - it can predict future fund shortages based on user behavior. The system learns from regular top-ups and typical spending patterns: when money usually arrives, which payments repeat and how spending changes across the days of the month.
If the forecast shows that funds will not be enough to cover standard obligations by the end of the period, DARCA warns the user in advance - and at the moment of initiating a new operation if it “consumes” money that typically goes toward mandatory expenses.
This directly reduces the market pain of “unpredictability” and errors: fewer missed payments, fewer unexpected declines, less stress and fewer support requests.
Example
“If you make this transfer now, there may not be enough to pay rent by the 20th. Do you want to continue or reserve the amount instead?”
Reserving Funds for a Goal and Timeframe
A user can allocate part of their balance into a “reserve” for a specific purpose: a payment, a trip, savings or a recurring bill. The reserve lives within the same unified framework: it is visible, included in guidance and protects against accidental spending.
This solves an everyday problem: the money exists, but “it has already been set aside for something” and the product helps maintain discipline without separate apps or spreadsheets.
Interface Templates Based on the User’s Goal
The Core supports different interface “modes”: a simpler one for basic scenarios and a more functional one for those who need more tools. The user sees only what they truly need right now, without screen overload.
This removes the pain of weak mobile banking and “overloaded” crypto apps: the interface becomes clear, fast, and does not intimidate newcomers.
Example
The same money framework, but different presentation: “receive/send” for the start, and an advanced mode when the user is ready.
Gamification, Learning, and Security Habits
The Core supports lightweight gamification: achievements for useful actions (enabling biometrics, setting up a backup channel, completing onboarding). Importantly: this is not “a game for the sake of a game”, but a mechanism that reduces mistakes and increases security.
This approach helps solve the market problem of “people make mistakes because they don’t understand” - and reduces the load on support.
Stories Inside the App
Stories are a short-format “navigation and attention” channel: updates, hints, warnings, micro-learning, and important changes in terms. This is a fast way to deliver critical information without long texts or email campaigns.
The market benefit: fewer misunderstandings, less chaos, and fewer situations of “I didn’t see it/I didn’t know”.
DARCA ID as the Foundation of the Ecosystem
DARCA ID is the user’s unified identity within the system: it connects access, history, documents, trust level, and communication with support. It is the “framework” that allows new functions and modules to be enabled without repeated registrations and without breaking the experience.
This directly targets fragmentation: one profile, one trust layer, and one action logic - regardless of which capabilities are enabled.
Note
Unified identity is not just a “login”, but the foundation of integrity: statuses, documents, access, and support are always tied to a single source of truth.
Modules
After the Core is activated, the platform unfolds through attachable modules - like “plugins” that add new scenarios without turning the app into an overloaded monolith.
In DARCA, we deliberately separate the product into the Core and modules. The Core is the universal foundation everyone needs: a unified profile, wallets, payments, documents, statuses, support, and a shared rules framework. Modules are extensions that users enable by choice and that “plug into” the familiar interface, using the shared context, transaction history and the same transparency principles.
Info
The user chooses which modules to enable and which to keep disabled: the product remains lightweight and not overloaded. A module is activated only if it does not conflict with regional requirements, the user’s KYC level, and subscription terms.
Below is the list of modules that unlock the full “external” functionality on top of the Core (each module is described in a separate file):
- Anti-Crisis Vault - a “capital protection” mode: rapid restrictions, reserving, and safe scenarios for stress events.
- Saving - goals and savings: automatic rules, gentle discipline, transparent progress.
- Mining - participation in mining/infrastructure scenarios and income tracking within the unified app framework.
- Messenger - financial actions directly inside chat: transfers, invoices, collections and documents with in-app confirmation.
- My Games - a module for gamers: integrations with games and platforms, viewing gaming balances and parameters, inventory and history; donations and purchases of in-game items directly from the bank - fast and transparent.
- Enhanced security - strengthened protection modes: additional confirmations, expanded transaction rules, and advanced checks.
- Token creation - issuing and managing tokens (for projects, communities or business scenarios).
- Staking - yield and staking with clear accruals, statuses, notifications and reporting.
- Habit tracker - managing habits and financial behavior linked to real actions inside the app.
- Cold Vault - asset storage modes with maximum security priority and access control.
- NFT - managing NFT assets and related scenarios within the unified ecosystem.
- P2P Exchange - P2P deals, extended trading/exchange scenarios, automation and activity analytics.
- RWA - working with tokenized real-world assets, documents and reporting within one framework.
Tip
Important: when a module is disabled, the “UI disappears”, but transaction history, statuses, and documents remain in the Core - the user does not lose context and can return to the module at any time.