Technical Overview and Transaction Flow
This section provides a high-level overview of how the THAT app interacts with public blockchains and other services, and how transactions are prepared and broadcast.
High-Level Architecture
At a high level, the THAT app:
runs as a mobile application on the user’s device
stores private keys locally in encrypted form
connects to public blockchain networks (for example, Ethereum and Polygon) via remote procedure call (RPC) endpoints and/or indexing services to read balances and transaction history
may connect to third-party protocols (such as decentralized exchanges, on-ramps and bridges) through standard interfaces.
The app is designed as a non-custodial interface. The Company does not operate user accounts holding customer funds and does not pool or intermediate user assets. Digital assets remain on public blockchains in addresses controlled by users’ keys.
Wallet Creation and Key Management
When a user creates a new wallet in the THAT app:
the app generates a mnemonic (seed) phrase and associated key material on the user’s device
private keys derived from the seed are stored locally in encrypted form, making use of device-level security features where available (for example, secure hardware modules, passcodes or biometrics)
the user is prompted to back up their seed phrase securely, as this is required to recover access if the device is lost.
The Company does not receive or store users’ mnemonic phrases or private keys and cannot restore access to a wallet if the user loses these credentials.
Reading Balances and Activity
To show balances and transaction history:
the THAT app queries supported blockchain networks and/or indexing services for the addresses associated with the user’s wallet
balances and recent transactions are displayed in a user-friendly format, based on data reported by the underlying networks
where applicable, the app may provide additional context (for example, token names, logos or historical summaries) to help users interpret this information.
These views are informational only and reflect data from public blockchains and third-party indexers.
Preparing and Broadcasting Transactions
When a user initiates a transfer (for example, sending THAT to a merchant):
Transaction preparation
The user selects an asset, enters or scans a destination address (or tag), and specifies an amount.
The app constructs an unsigned transaction for the relevant blockchain network, including appropriate fee or gas parameters based on network conditions.
Local signing
The unsigned transaction is presented to the user for review and confirmation.
If the user confirms, the transaction is signed on the device using the private key associated with the sending address.
The private key remains on the device and is not transmitted from the device.
Broadcast
The signed transaction is then broadcast to the relevant blockchain network via RPC endpoints or other standard interfaces.
Confirmation time and finality depend on the underlying network and its consensus mechanism.
Value moves directly between the sender’s and recipient’s addresses on-chain. The Company does not hold funds in transit and does not clear or settle transactions between users or merchants.
Interaction with Third-Party Protocols
In some areas, the THAT app provides interfaces to third-party protocols and services, for example:
Decentralized exchange (DEX) protocols – to enable users to swap between THAT and other supported digital assets.
On-ramp and off-ramp providers – to allow users to connect with regulated service providers for fiat-to-crypto or crypto-to-fiat services, where available.
Bridging infrastructure – to allow users to move THAT between supported networks.
In these cases:
the app helps users construct transactions or requests that interact with the relevant third-party contracts or services
where swaps or bridging occur, they are executed via smart contracts and/or service providers, not by the Company operating an exchange or order book
users remain responsible for reviewing and understanding the terms and risks of any third-party protocol or service they choose to use.
The availability and configuration of these integrations may change over time.
Example: Merchant Payment Flow
A typical on-chain payment from a user to a merchant using THAT may follow this pattern:
A merchant that independently chooses to accept digital assets shares a wallet address, ENS name or QR code with the customer, or appears in the merchant directory within the THAT app.
The user selects the merchant within the app or scans the QR code, chooses the asset (for example, THAT) and enters or confirms the amount.
The app prepares a transaction from the user’s wallet to the merchant’s address and displays a transfer confirmation screen.
The user reviews and confirms the transaction. The transaction is signed locally on the device and broadcast to the relevant network.
The merchant can view the transaction on-chain (for example, via a block explorer or within their own wallet view) and reconcile it with their existing point-of-sale or accounting systems.
At all times, digital assets move directly between user and merchant addresses on public blockchains. The Company does not operate a payment facility, does not hold funds on behalf of users or merchants, and does not guarantee or enforce any commercial arrangements between them.
Last updated