> For the complete documentation index, see [llms.txt](https://shakestock.gitbook.io/whitepaper/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://shakestock.gitbook.io/whitepaper/technology.md).

# Technology

The technical architecture behind SHAKESTOCK, connecting Telegram, movement validation, smart contracts, Robinhood Chain, and on-chain verification.

SHAKESTOCK is a product stack, not a single contract. The application layer records activity and maintains Shake Coins. The on-chain layer executes stock claims and delivers tokenized stock rewards.

```
Telegram Mini App → movement detection → Shake Coin accounting
→ stock claim interface → smart contract → Robinhood Chain
→ tokenized stock → Blockscout verification
```

### Architecture model

The following is a conceptual model of the mechanisms described in Whitepaper v1.1.

```
┌─────────────────────────────┐
│ Telegram Mini App           │
│ UI + user interaction       │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ Movement / Anti-Cheat Layer │
│ Sensor threshold            │
│ Debounce                    │
│ Device fingerprint          │
│ IP rate limit               │
│ Telegram identity           │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ Shake Coin Layer            │
│ Off-chain points            │
│ Daily earning limits        │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ Claim Transaction           │
│ Stock selection             │
│ Shake Coin amount           │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ Smart Contract              │
│ Claim enforcement           │
│ Replay protection           │
│ Daily cap                   │
│ Parameter state             │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ Robinhood Chain             │
│ Transaction execution       │
│ Token delivery              │
└──────────────┬──────────────┘
               ↓
┌─────────────────────────────┐
│ User Wallet                 │
│ Tokenized stock             │
└──────────────┬──────────────┘
               ↓
          Blockscout
```

### Layer responsibilities

| Layer                   | Responsibility                                                                                           |
| ----------------------- | -------------------------------------------------------------------------------------------------------- |
| Application / off-chain | User interaction, movement detection, Shake Coin accounting, and anti-cheat controls.                    |
| On-chain                | Claim execution, enforced limits, token state, emitted parameter-change events, and transaction records. |
| Explorer                | Public inspection and verification of completed blockchain transactions.                                 |

This separation keeps phone activity and internal points in the application layer. It also makes the completed claim and resulting token ownership observable on-chain.

### Technical boundary

Shake Coins are off-chain points. They are not the SHAKESTOCK token, stock token, or an on-chain ERC-20 balance.

A stock claim is the system transition between these layers. The application accepts a stock selection and Shake Coin amount. The smart contract then enforces the on-chain claim on Robinhood Chain. A successful transaction delivers the ERC-20 stock reward to the user's wallet.

### Component map

* **Telegram Mini App** provides the user-facing path from shaking to claim initiation.
* **Anti-cheat controls** validate activity before it becomes eligible for Shake Coin accounting.
* **Smart contracts** enforce on-chain claim constraints and token delivery.
* **Robinhood Chain** executes and records the transaction.
* **Blockscout** exposes the resulting transaction record for verification.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://shakestock.gitbook.io/whitepaper/technology.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.