diff --git a/.github/workflows/pool-tests.yml b/.github/workflows/pool-tests.yml
new file mode 100644
index 0000000..834af0a
--- /dev/null
+++ b/.github/workflows/pool-tests.yml
@@ -0,0 +1,57 @@
+name: Pool Contract Tests
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+    branches: [main]
+
+jobs:
+  clarinet-test:
+    name: Clarinet Unit Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Clarinet
+        run: |
+          curl -L https://github.com/hirosystems/clarinet/releases/latest/download/clarinet-linux-x64-glibc.tar.gz \
+            | tar -xz -C /usr/local/bin
+
+      - name: Run Clarinet checks
+        run: clarinet check
+
+      - name: Run contract tests
+        run: clarinet test --coverage
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v4
+        with:
+          file: coverage.lcov
+          fail_ci_if_error: false
+
+  typescript-test:
+    name: TypeScript Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        working-directory: frontend
+        run: npm ci
+
+      - name: Run TypeScript tests
+        working-directory: frontend
+        run: npm test -- --reporter=verbose
+
+      - name: Type check
+        working-directory: frontend
+        run: npx tsc --noEmit
diff --git a/Clarinet.toml b/Clarinet.toml
new file mode 100644
index 0000000..e1bbe9a
--- /dev/null
+++ b/Clarinet.toml
@@ -0,0 +1,37 @@
+[project]
+name = "bitstake"
+requirements = []
+authors = []
+telemetry = false
+
+[contracts.bitstake-pool-registry]
+path = "contracts/bitstake-pool-registry.clar"
+clarity_version = 2
+epoch = "2.5"
+
+[contracts.bitstake-pool-deposits]
+path = "contracts/bitstake-pool-deposits.clar"
+clarity_version = 2
+epoch = "2.5"
+
+[contracts.bitstake-lbstx]
+path = "contracts/bitstake-lbstx.clar"
+clarity_version = 2
+epoch = "2.5"
+
+[contracts.bitstake-bbstx]
+path = "contracts/bitstake-bbstx.clar"
+clarity_version = 2
+epoch = "2.5"
+
+[contracts.bitstake-mbstx]
+path = "contracts/bitstake-mbstx.clar"
+clarity_version = 2
+epoch = "2.5"
+
+[contracts.bitstake-rewards]
+path = "contracts/bitstake-rewards.clar"
+clarity_version = 2
+epoch = "2.5"
+
+[[deployment_plan.genesis]]
diff --git a/contracts/bitstake-bbstx.clar b/contracts/bitstake-bbstx.clar
new file mode 100644
index 0000000..881e313
--- /dev/null
+++ b/contracts/bitstake-bbstx.clar
@@ -0,0 +1,42 @@
+;; bitstake-bbstx.clar
+;; bbSTX — Balanced Pool liquid staking token (Pool 2, 3-cycle lockup)
+;; SIP-010 compliant
+
+(impl-trait 'SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard.sip-010-trait)
+
+(define-fungible-token bbstx)
+
+(define-constant CONTRACT-OWNER  tx-sender)
+(define-constant ERR-NOT-OWNER   (err u100))
+(define-constant ERR-NOT-SENDER  (err u101))
+(define-constant ERR-ZERO        (err u103))
+
+(define-data-var token-name    (string-ascii 32)           "Balanced bitstake STX")
+(define-data-var token-symbol  (string-ascii 10)           "bbSTX")
+(define-data-var token-decimals uint                       u6)
+(define-data-var token-uri     (optional (string-utf8 256)) none)
+
+(define-read-only (get-name)     (ok (var-get token-name)))
+(define-read-only (get-symbol)   (ok (var-get token-symbol)))
+(define-read-only (get-decimals) (ok (var-get token-decimals)))
+(define-read-only (get-balance (account principal)) (ok (ft-get-balance bbstx account)))
+(define-read-only (get-total-supply) (ok (ft-get-supply bbstx)))
+(define-read-only (get-token-uri) (ok (var-get token-uri)))
+
+(define-public (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))
+  (begin
+    (asserts! (is-eq tx-sender sender) ERR-NOT-SENDER)
+    (asserts! (> amount u0) ERR-ZERO)
+    (try! (ft-transfer? bbstx amount sender recipient))
+    (match memo m (print m) 0x)
+    (ok true)))
+
+(define-public (mint (amount uint) (recipient principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (ft-mint? bbstx amount recipient)))
+
+(define-public (burn (amount uint) (owner principal))
+  (begin
+    (asserts! (is-eq tx-sender owner) ERR-NOT-SENDER)
+    (ft-burn? bbstx amount owner)))
diff --git a/contracts/bitstake-lbstx.clar b/contracts/bitstake-lbstx.clar
new file mode 100644
index 0000000..795d85d
--- /dev/null
+++ b/contracts/bitstake-lbstx.clar
@@ -0,0 +1,42 @@
+;; bitstake-lbstx.clar
+;; lbSTX — Liquid Pool liquid staking token (Pool 1, 1-cycle lockup)
+;; SIP-010 compliant
+
+(impl-trait 'SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard.sip-010-trait)
+
+(define-fungible-token lbstx)
+
+(define-constant CONTRACT-OWNER  tx-sender)
+(define-constant ERR-NOT-OWNER   (err u100))
+(define-constant ERR-NOT-SENDER  (err u101))
+(define-constant ERR-ZERO        (err u103))
+
+(define-data-var token-name    (string-ascii 32)           "Liquid bitstake STX")
+(define-data-var token-symbol  (string-ascii 10)           "lbSTX")
+(define-data-var token-decimals uint                       u6)
+(define-data-var token-uri     (optional (string-utf8 256)) none)
+
+(define-read-only (get-name)     (ok (var-get token-name)))
+(define-read-only (get-symbol)   (ok (var-get token-symbol)))
+(define-read-only (get-decimals) (ok (var-get token-decimals)))
+(define-read-only (get-balance (account principal)) (ok (ft-get-balance lbstx account)))
+(define-read-only (get-total-supply) (ok (ft-get-supply lbstx)))
+(define-read-only (get-token-uri) (ok (var-get token-uri)))
+
+(define-public (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))
+  (begin
+    (asserts! (is-eq tx-sender sender) ERR-NOT-SENDER)
+    (asserts! (> amount u0) ERR-ZERO)
+    (try! (ft-transfer? lbstx amount sender recipient))
+    (match memo m (print m) 0x)
+    (ok true)))
+
+(define-public (mint (amount uint) (recipient principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (ft-mint? lbstx amount recipient)))
+
+(define-public (burn (amount uint) (owner principal))
+  (begin
+    (asserts! (is-eq tx-sender owner) ERR-NOT-SENDER)
+    (ft-burn? lbstx amount owner)))
diff --git a/contracts/bitstake-mbstx.clar b/contracts/bitstake-mbstx.clar
new file mode 100644
index 0000000..d247b07
--- /dev/null
+++ b/contracts/bitstake-mbstx.clar
@@ -0,0 +1,48 @@
+;; bitstake-mbstx.clar
+;; mbSTX — Maxi Pool liquid staking token (Pool 3, 12-cycle lockup)
+;; SIP-010 compliant
+
+(impl-trait 'SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard.sip-010-trait)
+
+(define-fungible-token mbstx)
+
+(define-constant CONTRACT-OWNER  tx-sender)
+(define-constant ERR-NOT-OWNER   (err u100))
+(define-constant ERR-NOT-SENDER  (err u101))
+(define-constant ERR-ZERO        (err u103))
+
+(define-data-var token-name    (string-ascii 32)           "Maxi bitstake STX")
+(define-data-var token-symbol  (string-ascii 10)           "mbSTX")
+(define-data-var token-decimals uint                       u6)
+(define-data-var token-uri     (optional (string-utf8 256)) none)
+
+(define-read-only (get-name)     (ok (var-get token-name)))
+(define-read-only (get-symbol)   (ok (var-get token-symbol)))
+(define-read-only (get-decimals) (ok (var-get token-decimals)))
+(define-read-only (get-balance (account principal)) (ok (ft-get-balance mbstx account)))
+(define-read-only (get-total-supply) (ok (ft-get-supply mbstx)))
+(define-read-only (get-token-uri) (ok (var-get token-uri)))
+
+(define-public (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))
+  (begin
+    (asserts! (is-eq tx-sender sender) ERR-NOT-SENDER)
+    (asserts! (> amount u0) ERR-ZERO)
+    (try! (ft-transfer? mbstx amount sender recipient))
+    (match memo m (print m) 0x)
+    (ok true)))
+
+(define-public (mint (amount uint) (recipient principal))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (ft-mint? mbstx amount recipient)))
+
+(define-public (burn (amount uint) (owner principal))
+  (begin
+    (asserts! (is-eq tx-sender owner) ERR-NOT-SENDER)
+    (ft-burn? mbstx amount owner)))
+
+(define-public (set-token-uri (new-uri (optional (string-utf8 256))))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (var-set token-uri new-uri)
+    (ok true)))
diff --git a/contracts/bitstake-pool-deposits.clar b/contracts/bitstake-pool-deposits.clar
new file mode 100644
index 0000000..f28f210
--- /dev/null
+++ b/contracts/bitstake-pool-deposits.clar
@@ -0,0 +1,106 @@
+;; bitstake-pool-deposits.clar
+;; Handles deposits and withdrawals for each pool tier
+
+(define-constant CONTRACT-OWNER    tx-sender)
+(define-constant ERR-NOT-OWNER     (err u100))
+(define-constant ERR-POOL-INACTIVE (err u102))
+(define-constant ERR-BELOW-MIN     (err u103))
+(define-constant ERR-NO-POSITION   (err u105))
+(define-constant ERR-LOCKED        (err u106))
+
+;; (pool-id, depositor) -> position
+(define-map positions
+  { pool-id: uint, depositor: principal }
+  {
+    amount:        uint,
+    deposited-at:  uint,
+    unlock-block:  uint
+  }
+)
+
+;; Track total deposited per user across all pools
+(define-map user-total-stacked principal uint)
+
+;; ── Deposit ───────────────────────────────────────────────────────────
+
+(define-public (deposit-to-pool (pool-id uint) (amount uint))
+  (let (
+    (pool    (unwrap! (contract-call? .bitstake-pool-registry get-pool pool-id) (err u101)))
+    (p-data  (unwrap! pool (err u101)))
+    (min-dep (get min-deposit p-data))
+    (cycles  (get lockup-cycles p-data))
+  )
+    (asserts! (get active p-data)       ERR-POOL-INACTIVE)
+    (asserts! (>= amount min-dep)       ERR-BELOW-MIN)
+
+    ;; Transfer STX to contract
+    (try! (stx-transfer? amount tx-sender (as-contract tx-sender)))
+
+    ;; Record position (add to existing if any)
+    (let (
+      (key     { pool-id: pool-id, depositor: tx-sender })
+      (existing (map-get? positions key))
+      (unlock  (+ block-height (* cycles u2100))) ;; ~2100 blocks per cycle
+    )
+      (match existing
+        pos (map-set positions key {
+          amount:       (+ (get amount pos) amount),
+          deposited-at: block-height,
+          unlock-block: unlock
+        })
+        (map-set positions key {
+          amount:       amount,
+          deposited-at: block-height,
+          unlock-block: unlock
+        })
+      )
+    )
+
+    ;; Update registry total
+    (try! (contract-call? .bitstake-pool-registry add-to-total pool-id amount))
+
+    (print { event: "deposit", pool-id: pool-id, depositor: tx-sender, amount: amount })
+    (ok true)
+  )
+)
+
+;; ── Withdraw ──────────────────────────────────────────────────────────
+
+(define-public (withdraw-from-pool (pool-id uint))
+  (let (
+    (key      { pool-id: pool-id, depositor: tx-sender })
+    (position (unwrap! (map-get? positions key) ERR-NO-POSITION))
+    (amount   (get amount position))
+  )
+    (asserts! (>= block-height (get unlock-block position)) ERR-LOCKED)
+
+    (map-delete positions key)
+    (try! (contract-call? .bitstake-pool-registry remove-from-total pool-id amount))
+    (try! (as-contract (stx-transfer? amount tx-sender tx-sender)))
+
+    (print { event: "withdrawal", pool-id: pool-id, depositor: tx-sender, amount: amount })
+    (ok amount)
+  )
+)
+
+;; ── Read-Only ─────────────────────────────────────────────────────────
+
+(define-read-only (get-position (pool-id uint) (depositor principal))
+  (ok (map-get? positions { pool-id: pool-id, depositor: depositor }))
+)
+
+(define-read-only (is-locked (pool-id uint) (depositor principal))
+  (match (map-get? positions { pool-id: pool-id, depositor: depositor })
+    pos (ok (< block-height (get unlock-block pos)))
+    (ok false)
+  )
+)
+
+(define-read-only (blocks-until-unlock (pool-id uint) (depositor principal))
+  (match (map-get? positions { pool-id: pool-id, depositor: depositor })
+    pos (if (>= block-height (get unlock-block pos))
+          (ok u0)
+          (ok (- (get unlock-block pos) block-height)))
+    (ok u0)
+  )
+)
diff --git a/contracts/bitstake-pool-registry.clar b/contracts/bitstake-pool-registry.clar
new file mode 100644
index 0000000..ab5bf2d
--- /dev/null
+++ b/contracts/bitstake-pool-registry.clar
@@ -0,0 +1,109 @@
+;; bitstake-pool-registry.clar
+;; Registry for all stacking pool tiers: Liquid, Balanced, Maxi
+
+(define-constant CONTRACT-OWNER   tx-sender)
+(define-constant ERR-NOT-OWNER    (err u100))
+(define-constant ERR-POOL-NOT-FOUND (err u101))
+(define-constant ERR-POOL-INACTIVE  (err u102))
+(define-constant ERR-BELOW-MINIMUM  (err u103))
+(define-constant ERR-ALREADY-EXISTS (err u104))
+
+;; Pool registry
+(define-map pools
+  uint
+  {
+    name:           (string-ascii 32),
+    lockup-cycles:  uint,
+    min-deposit:    uint,
+    total-stacked:  uint,
+    active:         bool,
+    token-symbol:   (string-ascii 10)
+  }
+)
+
+(define-data-var pool-count uint u0)
+
+;; ── Pool Management ───────────────────────────────────────────────────
+
+(define-public (create-pool
+  (name          (string-ascii 32))
+  (lockup-cycles uint)
+  (min-deposit   uint)
+  (token-symbol  (string-ascii 10))
+)
+  (let ((id (+ (var-get pool-count) u1)))
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (asserts! (> lockup-cycles u0) ERR-BELOW-MINIMUM)
+    (map-set pools id {
+      name:           name,
+      lockup-cycles:  lockup-cycles,
+      min-deposit:    min-deposit,
+      total-stacked:  u0,
+      active:         true,
+      token-symbol:   token-symbol
+    })
+    (var-set pool-count id)
+    (print { event: "pool-created", pool-id: id, name: name, lockup-cycles: lockup-cycles })
+    (ok id)
+  )
+)
+
+(define-public (set-pool-active (pool-id uint) (active bool))
+  (let ((pool (unwrap! (map-get? pools pool-id) ERR-POOL-NOT-FOUND)))
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (map-set pools pool-id (merge pool { active: active }))
+    (ok true)
+  )
+)
+
+;; Internal: update total-stacked when a deposit is made
+(define-public (add-to-total (pool-id uint) (amount uint))
+  (let ((pool (unwrap! (map-get? pools pool-id) ERR-POOL-NOT-FOUND)))
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (map-set pools pool-id (merge pool { total-stacked: (+ (get total-stacked pool) amount) }))
+    (ok true)
+  )
+)
+
+(define-public (remove-from-total (pool-id uint) (amount uint))
+  (let ((pool (unwrap! (map-get? pools pool-id) ERR-POOL-NOT-FOUND)))
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (map-set pools pool-id (merge pool { total-stacked: (- (get total-stacked pool) amount) }))
+    (ok true)
+  )
+)
+
+;; ── Read-Only ─────────────────────────────────────────────────────────
+
+(define-read-only (get-pool (pool-id uint))
+  (ok (map-get? pools pool-id))
+)
+
+(define-read-only (get-pool-count)
+  (ok (var-get pool-count))
+)
+
+(define-read-only (is-pool-active (pool-id uint))
+  (match (map-get? pools pool-id)
+    pool (ok (get active pool))
+    (ok false)
+  )
+)
+
+(define-read-only (get-min-deposit (pool-id uint))
+  (match (map-get? pools pool-id)
+    pool (ok (get min-deposit pool))
+    ERR-POOL-NOT-FOUND
+  )
+)
+
+;; ── Initialise Default Pools ──────────────────────────────────────────
+
+(begin
+  ;; Pool 1: Liquid — 1 cycle, 100 STX minimum
+  (try! (create-pool "Liquid" u1  u100000000   "lbSTX"))
+  ;; Pool 2: Balanced — 3 cycles, 500 STX minimum
+  (try! (create-pool "Balanced" u3 u500000000  "bbSTX"))
+  ;; Pool 3: Maxi — 12 cycles, 1000 STX minimum
+  (try! (create-pool "Maxi" u12 u1000000000   "mbSTX"))
+)
diff --git a/contracts/bitstake-rewards.clar b/contracts/bitstake-rewards.clar
new file mode 100644
index 0000000..d7d17be
--- /dev/null
+++ b/contracts/bitstake-rewards.clar
@@ -0,0 +1,82 @@
+;; bitstake-rewards.clar
+;; Tracks and distributes stacking rewards per pool tier
+
+(define-constant CONTRACT-OWNER   tx-sender)
+(define-constant ERR-NOT-OWNER    (err u100))
+(define-constant ERR-NO-REWARDS   (err u105))
+(define-constant ERR-ZERO         (err u103))
+
+;; reward-epoch -> pool-id -> total rewards (uSTX)
+(define-map epoch-rewards
+  { epoch: uint, pool-id: uint }
+  { total-reward: uint, total-stacked: uint }
+)
+
+;; (depositor, pool-id) -> last claimed epoch
+(define-map last-claimed
+  { depositor: principal, pool-id: uint }
+  uint
+)
+
+(define-data-var current-epoch uint u0)
+
+;; ── Epoch Management ──────────────────────────────────────────────────
+
+(define-public (advance-epoch)
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (var-set current-epoch (+ (var-get current-epoch) u1))
+    (print { event: "epoch-advanced", epoch: (var-get current-epoch) })
+    (ok (var-get current-epoch))
+  )
+)
+
+(define-public (record-epoch-rewards (pool-id uint) (reward-amount uint) (stacked-amount uint))
+  (let ((epoch (var-get current-epoch)))
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (asserts! (> reward-amount u0) ERR-ZERO)
+    (map-set epoch-rewards
+      { epoch: epoch, pool-id: pool-id }
+      { total-reward: reward-amount, total-stacked: stacked-amount }
+    )
+    (print { event: "rewards-recorded", epoch: epoch, pool-id: pool-id, reward: reward-amount })
+    (ok true)
+  )
+)
+
+;; ── Reward Calculation ────────────────────────────────────────────────
+
+(define-read-only (get-epoch-reward (epoch uint) (pool-id uint))
+  (map-get? epoch-rewards { epoch: epoch, pool-id: pool-id })
+)
+
+(define-read-only (get-current-epoch)
+  (ok (var-get current-epoch))
+)
+
+(define-read-only (get-last-claimed (depositor principal) (pool-id uint))
+  (default-to u0 (map-get? last-claimed { depositor: depositor, pool-id: pool-id }))
+)
+
+;; Estimate claimable rewards for a depositor in one epoch
+(define-read-only (estimate-epoch-reward (depositor principal) (pool-id uint) (epoch uint) (user-stacked uint))
+  (match (map-get? epoch-rewards { epoch: epoch, pool-id: pool-id })
+    data (if (> (get total-stacked data) u0)
+            (ok (/ (* user-stacked (get total-reward data)) (get total-stacked data)))
+            (ok u0))
+    (ok u0)
+  )
+)
+
+;; ── Claim ─────────────────────────────────────────────────────────────
+
+(define-public (mark-claimed (depositor principal) (pool-id uint))
+  (begin
+    (asserts! (is-eq tx-sender CONTRACT-OWNER) ERR-NOT-OWNER)
+    (map-set last-claimed
+      { depositor: depositor, pool-id: pool-id }
+      (var-get current-epoch)
+    )
+    (ok true)
+  )
+)
diff --git a/docs/multi-pool-tiers.md b/docs/multi-pool-tiers.md
new file mode 100644
index 0000000..a9f5003
--- /dev/null
+++ b/docs/multi-pool-tiers.md
@@ -0,0 +1,80 @@
+# Multi-Pool Strategy Tiers
+
+bitstake provides three distinct stacking pool tiers, each targeting a different risk/lockup/yield profile.
+
+## Pool Tiers
+
+| Pool | Token | Lockup | Min Deposit | Target APY |
+|------|-------|--------|-------------|------------|
+| Liquid   | lbSTX | 1 cycle (~15 days)  | 100 STX  | ~7%  |
+| Balanced | bbSTX | 3 cycles (~45 days) | 500 STX  | ~9%  |
+| Maxi     | mbSTX | 12 cycles (~6 months) | 1,000 STX | ~13% |
+
+A Stacks stacking cycle is approximately 2,100 blocks (~2 weeks).
+
+## Contracts
+
+### `bitstake-pool-registry`
+Central registry that defines each pool's parameters. Callable by the owner to:
+- Create new pool tiers
+- Activate / deactivate pools
+- Track total stacked per pool
+
+### `bitstake-pool-deposits`
+Handles user deposits and withdrawals. Key rules:
+- Deposits transfer STX to the contract and record a position with an `unlock-block`
+- `unlock-block = current-block + (lockup-cycles × 2100)`
+- Withdrawals are blocked until `block-height >= unlock-block` (ERR u106)
+- Deposits accumulate (add to existing position if one exists)
+
+### Token Contracts (`bitstake-lbstx`, `bitstake-bbstx`, `bitstake-mbstx`)
+SIP-010 fungible tokens representing pool shares. The owner (pool deposits contract) mints tokens 1:1 with deposits and burns on withdrawal.
+
+### `bitstake-rewards`
+Epoch-based reward accounting:
+- Owner advances epoch each stacking cycle
+- Per-epoch reward amounts are recorded per pool
+- Pro-rata reward estimation: `(user_stacked / total_stacked) × epoch_reward`
+
+## Error Codes
+
+| Code | Meaning |
+|------|---------|
+| `u100` | Not owner |
+| `u101` | Pool not found |
+| `u102` | Pool inactive |
+| `u103` | Below minimum deposit |
+| `u104` | Already exists |
+| `u105` | No position |
+| `u106` | Funds still locked |
+
+## Deposit Flow
+
+```
+User → deposit-to-pool(pool-id, amount)
+  → [check pool active]
+  → [check amount >= min-deposit]
+  → stx-transfer?(amount, tx-sender, contract)
+  → map-set positions { amount, deposited-at, unlock-block }
+  → add-to-total(pool-id, amount)
+  → (owner calls mint on token contract)
+```
+
+## Withdrawal Flow
+
+```
+User → withdraw-from-pool(pool-id)
+  → [check position exists]
+  → [check block-height >= unlock-block]
+  → map-delete positions
+  → remove-from-total(pool-id, amount)
+  → stx-transfer?(amount, contract, user)
+  → (owner calls burn on token contract)
+```
+
+## Deployment Order
+
+1. `bitstake-pool-registry` — initialises 3 default pools in `begin` block
+2. `bitstake-pool-deposits` — references registry via contract-call?
+3. Token contracts (`lbstx`, `bbstx`, `mbstx`) — minted/burned by deposits contract
+4. `bitstake-rewards` — standalone, updated by owner each epoch
diff --git a/frontend/src/components/DepositForm.tsx b/frontend/src/components/DepositForm.tsx
new file mode 100644
index 0000000..c5987a0
--- /dev/null
+++ b/frontend/src/components/DepositForm.tsx
@@ -0,0 +1,106 @@
+import React, { useState } from "react";
+import { openContractCall } from "@stacks/connect";
+import { Cl } from "@stacks/transactions";
+import type { PoolData } from "../hooks/usePoolTiers";
+import { CONTRACTS, STACKS_NETWORK } from "../constants/pools";
+
+interface DepositFormProps {
+  pool: PoolData;
+  userAddress: string;
+  onSuccess: (amount: bigint) => void;
+}
+
+export function DepositForm({ pool, userAddress, onSuccess }: DepositFormProps) {
+  const [amountStr, setAmountStr] = useState("");
+  const [status, setStatus] = useState<"idle" | "pending" | "success" | "error">("idle");
+  const [errorMsg, setErrorMsg] = useState("");
+
+  const amountSTX = parseFloat(amountStr) || 0;
+  const amountMicro = BigInt(Math.floor(amountSTX * 1_000_000));
+  const isValid = amountSTX >= pool.minDepositSTX && !isNaN(amountSTX);
+
+  async function handleDeposit(e: React.FormEvent) {
+    e.preventDefault();
+    if (!isValid) return;
+
+    setStatus("pending");
+    setErrorMsg("");
+
+    const [contractAddress, contractName] = CONTRACTS.POOL_DEPOSITS.split(".");
+
+    try {
+      await openContractCall({
+        network: STACKS_NETWORK,
+        contractAddress,
+        contractName,
+        functionName: "deposit-to-pool",
+        functionArgs: [Cl.uint(pool.id), Cl.uint(amountMicro)],
+        postConditionMode: 1,
+        onFinish: () => {
+          setStatus("success");
+          onSuccess(amountMicro);
+          setAmountStr("");
+        },
+        onCancel: () => {
+          setStatus("idle");
+        },
+      });
+    } catch (err: any) {
+      setStatus("error");
+      setErrorMsg(err?.message ?? "Transaction failed");
+    }
+  }
+
+  return (
+    <form className="deposit-form" onSubmit={handleDeposit} aria-label="Deposit form">
+      <h3 className="deposit-form__title">
+        Deposit to {pool.name} Pool ({pool.tokenSymbol})
+      </h3>
+
+      <div className="deposit-form__field">
+        <label htmlFor="amount" className="deposit-form__label">
+          Amount (STX)
+        </label>
+        <input
+          id="amount"
+          type="number"
+          min={pool.minDepositSTX}
+          step="0.000001"
+          value={amountStr}
+          onChange={(e) => setAmountStr(e.target.value)}
+          placeholder={`Min ${pool.minDepositSTX.toLocaleString()} STX`}
+          className="deposit-form__input"
+          aria-invalid={amountStr !== "" && !isValid}
+          disabled={status === "pending"}
+        />
+        {amountStr !== "" && !isValid && (
+          <p className="deposit-form__error" role="alert">
+            Minimum deposit is {pool.minDepositSTX.toLocaleString()} STX
+          </p>
+        )}
+      </div>
+
+      <div className="deposit-form__lockup-notice">
+        Funds will be locked for ~{pool.lockupDays} days ({pool.lockupCycles}{" "}
+        stacking cycle{pool.lockupCycles > 1 ? "s" : ""}).
+      </div>
+
+      <button
+        type="submit"
+        className="deposit-form__submit"
+        disabled={!isValid || status === "pending"}
+      >
+        {status === "pending" ? "Waiting for wallet…" : `Deposit ${amountSTX > 0 ? amountSTX.toLocaleString() + " STX" : ""}`}
+      </button>
+
+      {status === "success" && (
+        <p className="deposit-form__success" role="status">
+          Deposit submitted! You will receive {pool.tokenSymbol} tokens once confirmed.
+        </p>
+      )}
+      {status === "error" && (
+        <p className="deposit-form__error" role="alert">{errorMsg}</p>
+      )}
+    </form>
+  );
+}
diff --git a/frontend/src/components/PoolSelector.tsx b/frontend/src/components/PoolSelector.tsx
new file mode 100644
index 0000000..fc91bdb
--- /dev/null
+++ b/frontend/src/components/PoolSelector.tsx
@@ -0,0 +1,59 @@
+import React, { useState } from "react";
+import { usePoolTiers } from "../hooks/usePoolTiers";
+import { PoolTierCard } from "./PoolTierCard";
+import { DepositForm } from "./DepositForm";
+
+interface PoolSelectorProps {
+  userAddress: string | null;
+  onDepositSuccess?: (poolId: number, amount: bigint) => void;
+}
+
+export function PoolSelector({ userAddress, onDepositSuccess }: PoolSelectorProps) {
+  const { pools, isLoading, refetch } = usePoolTiers();
+  const [selectedPoolId, setSelectedPoolId] = useState<number | null>(null);
+
+  const selectedPool = pools.find((p) => p.id === selectedPoolId) ?? null;
+
+  return (
+    <section className="pool-selector" aria-label="Pool tier selection">
+      <h2 className="pool-selector__title">Choose Your Stacking Pool</h2>
+      <p className="pool-selector__subtitle">
+        Select a pool tier that matches your lockup preference and yield target.
+      </p>
+
+      {isLoading ? (
+        <div className="pool-selector__loading" aria-busy="true">
+          Loading pools…
+        </div>
+      ) : (
+        <div className="pool-selector__grid">
+          {pools.map((pool) => (
+            <PoolTierCard
+              key={pool.id}
+              pool={pool}
+              onSelect={setSelectedPoolId}
+              selected={selectedPoolId === pool.id}
+            />
+          ))}
+        </div>
+      )}
+
+      {selectedPool && userAddress && (
+        <DepositForm
+          pool={selectedPool}
+          userAddress={userAddress}
+          onSuccess={(amount) => {
+            refetch();
+            onDepositSuccess?.(selectedPool.id, amount);
+          }}
+        />
+      )}
+
+      {selectedPool && !userAddress && (
+        <p className="pool-selector__connect-prompt">
+          Connect your wallet to deposit into the {selectedPool.name} pool.
+        </p>
+      )}
+    </section>
+  );
+}
diff --git a/frontend/src/components/PoolTierCard.tsx b/frontend/src/components/PoolTierCard.tsx
new file mode 100644
index 0000000..faf313b
--- /dev/null
+++ b/frontend/src/components/PoolTierCard.tsx
@@ -0,0 +1,72 @@
+import React from "react";
+import type { PoolData } from "../hooks/usePoolTiers";
+
+interface PoolTierCardProps {
+  pool: PoolData;
+  onSelect: (poolId: number) => void;
+  selected: boolean;
+}
+
+function formatSTX(ustx: bigint): string {
+  return (Number(ustx) / 1_000_000).toLocaleString(undefined, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  });
+}
+
+export function PoolTierCard({ pool, onSelect, selected }: PoolTierCardProps) {
+  if (pool.isLoading) {
+    return (
+      <div className="pool-card pool-card--loading">
+        <div className="skeleton skeleton--title" />
+        <div className="skeleton skeleton--line" />
+        <div className="skeleton skeleton--line" />
+      </div>
+    );
+  }
+
+  return (
+    <div
+      className={`pool-card ${selected ? "pool-card--selected" : ""} ${!pool.active ? "pool-card--inactive" : ""}`}
+      role="button"
+      tabIndex={0}
+      aria-pressed={selected}
+      onClick={() => pool.active && onSelect(pool.id)}
+      onKeyDown={(e) => e.key === "Enter" && pool.active && onSelect(pool.id)}
+    >
+      <div className="pool-card__header">
+        <span className="pool-card__name">{pool.name}</span>
+        <span className="pool-card__token">{pool.tokenSymbol}</span>
+        {!pool.active && <span className="pool-card__badge pool-card__badge--inactive">Inactive</span>}
+      </div>
+
+      <div className="pool-card__apy">{pool.apy} APY</div>
+
+      <dl className="pool-card__stats">
+        <div className="pool-card__stat">
+          <dt>Lockup</dt>
+          <dd>{pool.lockupCycles} cycle{pool.lockupCycles > 1 ? "s" : ""} (~{pool.lockupDays} days)</dd>
+        </div>
+        <div className="pool-card__stat">
+          <dt>Min. Deposit</dt>
+          <dd>{pool.minDepositSTX.toLocaleString()} STX</dd>
+        </div>
+        <div className="pool-card__stat">
+          <dt>Total Stacked</dt>
+          <dd>{formatSTX(pool.totalStacked)} STX</dd>
+        </div>
+      </dl>
+
+      <p className="pool-card__description">{pool.description}</p>
+
+      {pool.active && (
+        <button
+          className={`pool-card__cta ${selected ? "pool-card__cta--selected" : ""}`}
+          onClick={(e) => { e.stopPropagation(); onSelect(pool.id); }}
+        >
+          {selected ? "Selected" : "Select Pool"}
+        </button>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/constants/pools.ts b/frontend/src/constants/pools.ts
new file mode 100644
index 0000000..a4c4b4c
--- /dev/null
+++ b/frontend/src/constants/pools.ts
@@ -0,0 +1,60 @@
+import { STACKS_TESTNET } from "@stacks/network";
+
+export const STACKS_NETWORK = new STACKS_TESTNET();
+
+export const CONTRACT_DEPLOYER = "ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM";
+
+export const CONTRACTS = {
+  POOL_REGISTRY: `${CONTRACT_DEPLOYER}.bitstake-pool-registry`,
+  POOL_DEPOSITS:  `${CONTRACT_DEPLOYER}.bitstake-pool-deposits`,
+  LBSTX_TOKEN:   `${CONTRACT_DEPLOYER}.bitstake-lbstx`,
+  BBSTX_TOKEN:   `${CONTRACT_DEPLOYER}.bitstake-bbstx`,
+  MBSTX_TOKEN:   `${CONTRACT_DEPLOYER}.bitstake-mbstx`,
+  REWARDS:       `${CONTRACT_DEPLOYER}.bitstake-rewards`,
+};
+
+export interface PoolTier {
+  id: number;
+  name: string;
+  lockupCycles: number;
+  lockupDays: number;
+  minDepositSTX: number;
+  tokenSymbol: string;
+  apy: string;        // indicative, fetched from backend
+  description: string;
+}
+
+export const POOL_TIERS: PoolTier[] = [
+  {
+    id: 1,
+    name: "Liquid",
+    lockupCycles: 1,
+    lockupDays: 15,
+    minDepositSTX: 100,
+    tokenSymbol: "lbSTX",
+    apy: "~7%",
+    description: "Shortest lockup, lower yield. Ideal for flexible stacking.",
+  },
+  {
+    id: 2,
+    name: "Balanced",
+    lockupCycles: 3,
+    lockupDays: 45,
+    minDepositSTX: 500,
+    tokenSymbol: "bbSTX",
+    apy: "~9%",
+    description: "Medium-term lockup with moderate yield. Best risk/reward.",
+  },
+  {
+    id: 3,
+    name: "Maxi",
+    lockupCycles: 12,
+    lockupDays: 180,
+    minDepositSTX: 1000,
+    tokenSymbol: "mbSTX",
+    apy: "~13%",
+    description: "Long-term lockup, highest yield. For committed stackers.",
+  },
+];
+
+export const BLOCKS_PER_CYCLE = 2100;
diff --git a/frontend/src/hooks/usePoolTiers.ts b/frontend/src/hooks/usePoolTiers.ts
new file mode 100644
index 0000000..4502815
--- /dev/null
+++ b/frontend/src/hooks/usePoolTiers.ts
@@ -0,0 +1,62 @@
+import { useState, useEffect } from "react";
+import { cvToValue, fetchReadOnlyFunction } from "@stacks/transactions";
+import { CONTRACTS, POOL_TIERS, STACKS_NETWORK, type PoolTier } from "../constants/pools";
+
+export interface PoolData extends PoolTier {
+  totalStacked: bigint;
+  active: boolean;
+  isLoading: boolean;
+}
+
+export function usePoolTiers(): { pools: PoolData[]; isLoading: boolean; refetch: () => void } {
+  const [pools, setPools] = useState<PoolData[]>(
+    POOL_TIERS.map((t) => ({ ...t, totalStacked: 0n, active: true, isLoading: true }))
+  );
+  const [isLoading, setIsLoading] = useState(true);
+  const [tick, setTick] = useState(0);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function fetchAll() {
+      setIsLoading(true);
+      const [registryAddress, registryName] = CONTRACTS.POOL_REGISTRY.split(".");
+
+      const updated = await Promise.all(
+        POOL_TIERS.map(async (tier) => {
+          try {
+            const result = await fetchReadOnlyFunction(
+              {
+                contractAddress: registryAddress,
+                contractName: registryName,
+                functionName: "get-pool",
+                functionArgs: [{ type: "uint", value: BigInt(tier.id) }],
+                network: STACKS_NETWORK,
+              },
+              true
+            );
+            const data = cvToValue(result as any);
+            return {
+              ...tier,
+              totalStacked: BigInt(data?.value?.["total-stacked"] ?? 0),
+              active: Boolean(data?.value?.active),
+              isLoading: false,
+            };
+          } catch {
+            return { ...tier, totalStacked: 0n, active: true, isLoading: false };
+          }
+        })
+      );
+
+      if (!cancelled) {
+        setPools(updated);
+        setIsLoading(false);
+      }
+    }
+
+    fetchAll();
+    return () => { cancelled = true; };
+  }, [tick]);
+
+  return { pools, isLoading, refetch: () => setTick((t) => t + 1) };
+}
diff --git a/frontend/src/hooks/useUserPosition.ts b/frontend/src/hooks/useUserPosition.ts
new file mode 100644
index 0000000..9c8c834
--- /dev/null
+++ b/frontend/src/hooks/useUserPosition.ts
@@ -0,0 +1,71 @@
+import { useState, useEffect } from "react";
+import { cvToValue, fetchReadOnlyFunction } from "@stacks/transactions";
+import { CONTRACTS, BLOCKS_PER_CYCLE, STACKS_NETWORK } from "../constants/pools";
+
+export interface UserPosition {
+  poolId: number;
+  amount: bigint;
+  depositedAt: bigint;
+  unlockBlock: bigint;
+  isLocked: boolean;
+  blocksUntilUnlock: bigint;
+  isLoading: boolean;
+}
+
+export function useUserPosition(poolId: number, userAddress: string | null) {
+  const [position, setPosition] = useState<UserPosition | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  useEffect(() => {
+    if (!userAddress) { setPosition(null); return; }
+    let cancelled = false;
+    setIsLoading(true);
+
+    const [depAddress, depName] = CONTRACTS.POOL_DEPOSITS.split(".");
+
+    async function fetch() {
+      try {
+        const result = await fetchReadOnlyFunction(
+          {
+            contractAddress: depAddress,
+            contractName: depName,
+            functionName: "get-position",
+            functionArgs: [
+              { type: "uint", value: BigInt(poolId) },
+              { type: "principal", value: userAddress },
+            ],
+            network: STACKS_NETWORK,
+          },
+          true
+        );
+        const raw = cvToValue(result as any);
+        if (!raw || raw.value === null) {
+          if (!cancelled) { setPosition(null); setIsLoading(false); }
+          return;
+        }
+        const d = raw.value;
+        const unlockBlock = BigInt(d["unlock-block"]);
+        // Approximate current block from chain tip — simplification
+        const currentBlock = BigInt(Date.now()); // placeholder; real impl uses @stacks/blockchain-api-client
+        if (!cancelled) {
+          setPosition({
+            poolId,
+            amount: BigInt(d.amount),
+            depositedAt: BigInt(d["deposited-at"]),
+            unlockBlock,
+            isLocked: currentBlock < unlockBlock,
+            blocksUntilUnlock: currentBlock < unlockBlock ? unlockBlock - currentBlock : 0n,
+            isLoading: false,
+          });
+          setIsLoading(false);
+        }
+      } catch {
+        if (!cancelled) { setPosition(null); setIsLoading(false); }
+      }
+    }
+    fetch();
+    return () => { cancelled = true; };
+  }, [poolId, userAddress]);
+
+  return { position, isLoading };
+}
diff --git a/scripts/deploy-pools.ts b/scripts/deploy-pools.ts
new file mode 100644
index 0000000..05e6cc4
--- /dev/null
+++ b/scripts/deploy-pools.ts
@@ -0,0 +1,79 @@
+#!/usr/bin/env ts-node
+/**
+ * deploy-pools.ts
+ * Deploy all bitstake pool contracts to Stacks testnet.
+ * Usage: DEPLOYER_KEY=<hex-private-key> ts-node scripts/deploy-pools.ts
+ */
+
+import {
+  makeContractDeploy,
+  broadcastTransaction,
+  AnchorMode,
+  PostConditionMode,
+} from "@stacks/transactions";
+import { StacksTestnet } from "@stacks/network";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+const network = new StacksTestnet();
+const senderKey = process.env.DEPLOYER_KEY;
+if (!senderKey) {
+  console.error("ERROR: DEPLOYER_KEY environment variable is required");
+  process.exit(1);
+}
+
+interface ContractDef {
+  name: string;
+  file: string;
+}
+
+const CONTRACTS: ContractDef[] = [
+  { name: "bitstake-pool-registry", file: "contracts/bitstake-pool-registry.clar" },
+  { name: "bitstake-pool-deposits", file: "contracts/bitstake-pool-deposits.clar" },
+  { name: "bitstake-lbstx",         file: "contracts/bitstake-lbstx.clar" },
+  { name: "bitstake-bbstx",         file: "contracts/bitstake-bbstx.clar" },
+  { name: "bitstake-mbstx",         file: "contracts/bitstake-mbstx.clar" },
+  { name: "bitstake-rewards",        file: "contracts/bitstake-rewards.clar" },
+];
+
+async function deploy(contract: ContractDef, nonce: bigint): Promise<string> {
+  const code = readFileSync(resolve(__dirname, "..", contract.file), "utf8");
+  const tx = await makeContractDeploy({
+    contractName: contract.name,
+    codeBody: code,
+    senderKey,
+    network,
+    anchorMode: AnchorMode.Any,
+    postConditionMode: PostConditionMode.Allow,
+    nonce,
+    fee: 10_000n,
+  });
+  const result = await broadcastTransaction({ transaction: tx, network });
+  if ("error" in result) {
+    throw new Error(`Deploy failed for ${contract.name}: ${result.error} — ${result.reason}`);
+  }
+  return result.txid;
+}
+
+async function main() {
+  console.log("🚀 Deploying bitstake pool contracts to testnet…\n");
+  let nonce = 0n;
+
+  for (const contract of CONTRACTS) {
+    process.stdout.write(`  Deploying ${contract.name}… `);
+    try {
+      const txid = await deploy(contract, nonce);
+      console.log(`✅ txid: ${txid}`);
+      nonce++;
+      // small delay between deploys
+      await new Promise((r) => setTimeout(r, 2000));
+    } catch (err: any) {
+      console.error(`\n  ❌ ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  console.log("\n✅ All contracts deployed successfully.");
+}
+
+main();
diff --git a/tests/bitstake-pool-deposits.test.ts b/tests/bitstake-pool-deposits.test.ts
new file mode 100644
index 0000000..23f1bbb
--- /dev/null
+++ b/tests/bitstake-pool-deposits.test.ts
@@ -0,0 +1,146 @@
+import { describe, expect, it } from "vitest";
+import { Cl } from "@stacks/transactions";
+import { initSimnet } from "@hirosystems/clarinet-sdk";
+
+const simnet = await initSimnet();
+const accounts = simnet.getAccounts();
+const deployer = accounts.get("deployer")!;
+const wallet1 = accounts.get("wallet_1")!;
+const wallet2 = accounts.get("wallet_2")!;
+
+const POOL_LIQUID   = 1n;
+const POOL_BALANCED = 2n;
+const POOL_MAXI     = 3n;
+
+describe("bitstake-pool-deposits", () => {
+  it("rejects deposit below minimum for Pool 1 (100 STX)", () => {
+    const result = simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(50_000_000)],
+      wallet1
+    );
+    expect(result.result).toBeErr(Cl.uint(103));
+  });
+
+  it("accepts deposit at exactly minimum for Pool 1", () => {
+    const result = simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(100_000_000)],
+      wallet1
+    );
+    expect(result.result).toBeOk(Cl.bool(true));
+  });
+
+  it("records correct position after deposit", () => {
+    simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(200_000_000)],
+      wallet2
+    );
+    const pos = simnet.callReadOnlyFn(
+      "bitstake-pool-deposits",
+      "get-position",
+      [Cl.uint(POOL_LIQUID), Cl.principal(wallet2)],
+      deployer
+    );
+    expect(pos.result).toBeOk(
+      Cl.some(
+        Cl.tuple({
+          amount: Cl.uint(200_000_000),
+          "deposited-at": Cl.uint(simnet.blockHeight),
+          "unlock-block": Cl.uint(simnet.blockHeight + 2100),
+        })
+      )
+    );
+  });
+
+  it("adds to existing position on second deposit", () => {
+    simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(100_000_000)],
+      wallet1
+    );
+    simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(100_000_000)],
+      wallet1
+    );
+    const pos = simnet.callReadOnlyFn(
+      "bitstake-pool-deposits",
+      "get-position",
+      [Cl.uint(POOL_LIQUID), Cl.principal(wallet1)],
+      deployer
+    );
+    // Total should be 200 STX
+    const data = pos.result as any;
+    expect(data.value.data.amount.value).toBe(200_000_000n);
+  });
+
+  it("blocks withdrawal before unlock-block", () => {
+    simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(100_000_000)],
+      wallet2
+    );
+    const result = simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "withdraw-from-pool",
+      [Cl.uint(POOL_LIQUID)],
+      wallet2
+    );
+    expect(result.result).toBeErr(Cl.uint(106));
+  });
+
+  it("returns ERR-NO-POSITION when withdrawing without a deposit", () => {
+    const result = simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "withdraw-from-pool",
+      [Cl.uint(POOL_MAXI)],
+      wallet1
+    );
+    expect(result.result).toBeErr(Cl.uint(105));
+  });
+
+  it("is-locked returns false when no position exists", () => {
+    const result = simnet.callReadOnlyFn(
+      "bitstake-pool-deposits",
+      "is-locked",
+      [Cl.uint(POOL_BALANCED), Cl.principal(wallet1)],
+      deployer
+    );
+    expect(result.result).toBeOk(Cl.bool(false));
+  });
+
+  it("blocks-until-unlock returns 0 when no position", () => {
+    const result = simnet.callReadOnlyFn(
+      "bitstake-pool-deposits",
+      "blocks-until-unlock",
+      [Cl.uint(POOL_MAXI), Cl.principal(wallet2)],
+      deployer
+    );
+    expect(result.result).toBeOk(Cl.uint(0));
+  });
+
+  it("rejects deposit to inactive pool", () => {
+    // Deactivate Pool 1 via registry
+    simnet.callPublicFn(
+      "bitstake-pool-registry",
+      "set-pool-active",
+      [Cl.uint(POOL_LIQUID), Cl.bool(false)],
+      deployer
+    );
+    const result = simnet.callPublicFn(
+      "bitstake-pool-deposits",
+      "deposit-to-pool",
+      [Cl.uint(POOL_LIQUID), Cl.uint(100_000_000)],
+      wallet1
+    );
+    expect(result.result).toBeErr(Cl.uint(102));
+  });
+});
diff --git a/tests/bitstake-pool-registry.test.ts b/tests/bitstake-pool-registry.test.ts
new file mode 100644
index 0000000..acb6224
--- /dev/null
+++ b/tests/bitstake-pool-registry.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { Cl } from "@stacks/transactions";
+import { initSimnet } from "@hirosystems/clarinet-sdk";
+
+const simnet = await initSimnet();
+const accounts = simnet.getAccounts();
+const deployer = accounts.get("deployer")!;
+const wallet1 = accounts.get("wallet_1")!;
+
+describe("bitstake-pool-registry", () => {
+  it("initialises with 3 default pools", () => {
+    const count = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "get-pool-count",
+      [],
+      deployer
+    );
+    expect(count.result).toBeUint(3);
+  });
+
+  it("pool 1 is Liquid with 1 lockup cycle", () => {
+    const pool = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "get-pool",
+      [Cl.uint(1)],
+      deployer
+    );
+    expect(pool.result).toBeSome(
+      Cl.tuple({
+        name: Cl.stringAscii("Liquid"),
+        "lockup-cycles": Cl.uint(1),
+        "min-deposit": Cl.uint(100000000),
+        "total-stacked": Cl.uint(0),
+        active: Cl.bool(true),
+        "token-symbol": Cl.stringAscii("lbSTX"),
+      })
+    );
+  });
+
+  it("pool 2 is Balanced with 3 lockup cycles", () => {
+    const pool = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "get-pool",
+      [Cl.uint(2)],
+      deployer
+    );
+    expect(pool.result).toBeSome(
+      Cl.tuple({
+        name: Cl.stringAscii("Balanced"),
+        "lockup-cycles": Cl.uint(3),
+        "min-deposit": Cl.uint(500000000),
+        "total-stacked": Cl.uint(0),
+        active: Cl.bool(true),
+        "token-symbol": Cl.stringAscii("bbSTX"),
+      })
+    );
+  });
+
+  it("pool 3 is Maxi with 12 lockup cycles", () => {
+    const pool = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "get-pool",
+      [Cl.uint(3)],
+      deployer
+    );
+    expect(pool.result).toBeSome(
+      Cl.tuple({
+        name: Cl.stringAscii("Maxi"),
+        "lockup-cycles": Cl.uint(12),
+        "min-deposit": Cl.uint(1000000000),
+        "total-stacked": Cl.uint(0),
+        active: Cl.bool(true),
+        "token-symbol": Cl.stringAscii("mbSTX"),
+      })
+    );
+  });
+
+  it("non-owner cannot create a new pool", () => {
+    const result = simnet.callPublicFn(
+      "bitstake-pool-registry",
+      "create-pool",
+      [
+        Cl.stringAscii("Elite"),
+        Cl.uint(24),
+        Cl.uint(5000000000),
+        Cl.stringAscii("ebSTX"),
+      ],
+      wallet1
+    );
+    expect(result.result).toBeErr(Cl.uint(100));
+  });
+
+  it("owner can deactivate a pool", () => {
+    simnet.callPublicFn(
+      "bitstake-pool-registry",
+      "set-pool-active",
+      [Cl.uint(1), Cl.bool(false)],
+      deployer
+    );
+    const active = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "is-pool-active",
+      [Cl.uint(1)],
+      deployer
+    );
+    expect(active.result).toBeOk(Cl.bool(false));
+  });
+
+  it("returns false for non-existent pool active check", () => {
+    const active = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "is-pool-active",
+      [Cl.uint(99)],
+      deployer
+    );
+    expect(active.result).toBeOk(Cl.bool(false));
+  });
+
+  it("returns pool-not-found for unknown pool get-min-deposit", () => {
+    const min = simnet.callReadOnlyFn(
+      "bitstake-pool-registry",
+      "get-min-deposit",
+      [Cl.uint(99)],
+      deployer
+    );
+    expect(min.result).toBeErr(Cl.uint(101));
+  });
+});