From 85350caf52866ba1e2aab0f213257aa3da404cf9 Mon Sep 17 00:00:00 2001
From: openhands <openhands@all-hands.dev>
Date: Fri, 13 Feb 2026 18:21:18 +0000
Subject: [PATCH] feat: OptimizerV3 with direct 2D staking-to-LP parameter
 mapping
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Core protocol changes for launch readiness:

- OptimizerV3: binary bear/bull mapping from (staking%, avgTax) — avoids
  exploitable AW 30-90 kill zone. Bear: AS=30%, AW=100, CI=0, DD=0.3e18.
  Bull: AS=100%, AW=20, CI=0, DD=1e18. UUPS upgradeable with __gap[48].
- Directional VWAP: only records prices on ETH inflow (buys), preventing
  sell-side dilution of price memory
- Floor formula: unified max(scarcity, mirror, clamp) — VWAP mirror uses
  distance from adjusted VWAP as floor distance, no branching
- PriceOracle (M-1 fix): correct fallback TWAP divisor (60000s, not 300s)
- Access control (M-2 fix): deployer-only guard on one-time setters
- Recenter rate limit (M-3 fix): 60-second cooldown for open recenters
- Safe fallback params: recenter() optimizer-failure defaults changed from
  exploitable CI=50%/AW=50 to safe bear-mode CI=0/AW=100
- Recentered event for monitoring and indexing
- VERSION bump to 2, kraiken-lib COMPATIBLE_CONTRACT_VERSIONS updated

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .claude-code-supervisor.yml                   |   26 +
 .claude/hooks/supervisor/lib.sh               |  139 ++
 .claude/hooks/supervisor/on-error.sh          |   40 +
 .claude/hooks/supervisor/on-notify.sh         |   44 +
 .claude/hooks/supervisor/on-stop.sh           |   71 +
 .claude/hooks/supervisor/triage.sh            |   72 +
 .claude/settings.json                         |   37 +
 .husky/pre-commit                             |    5 +-
 TECHNICAL_APPENDIX.md                         |   49 +-
 docs/DEPLOYMENT_RUNBOOK.md                    |  306 ++++
 kraiken-lib/src/version.ts                    |    5 +-
 landing/src/views/docs/AiAgent.vue            |   71 +-
 landing/src/views/docs/FaqDocs.vue            |    7 +-
 landing/src/views/docs/HarbergerTax.vue       |    8 +-
 landing/src/views/docs/HoldersDocs.vue        |   18 +-
 .../src/views/docs/LiquidityManagement.vue    |   23 +-
 landing/src/views/docs/StakingDocs.vue        |    4 +-
 onchain/src/Kraiken.sol                       |   11 +-
 onchain/src/LiquidityManager.sol              |  100 +-
 onchain/src/OptimizerV2.sol                   |  131 ++
 onchain/src/OptimizerV3.sol                   |  191 +++
 onchain/src/VWAPTracker.sol                   |    3 +-
 onchain/src/abstracts/PriceOracle.sol         |    5 +-
 .../src/abstracts/ThreePositionStrategy.sol   |   96 +-
 onchain/src/libraries/UniswapMath.sol         |    9 +-
 onchain/test/EthScarcityAbundance.t.sol       |  480 ++++++
 onchain/test/FuzzingAnalyzerBugs.t.sol        | 1317 +++++++++++++++++
 onchain/test/OptimizerV3.t.sol                |  232 +++
 onchain/test/abstracts/PriceOracle.t.sol      |   81 +-
 .../abstracts/ThreePositionStrategy.t.sol     |   73 +-
 onchain/test/helpers/TestBase.sol             |    4 +-
 scripts/bootstrap-common.sh                   |    4 +-
 services/ponder/abis/Kraiken.json             |    2 +-
 services/ponder/abis/Stake.json               |    2 +-
 tests/e2e/02-max-stake-all-tax-rates.spec.ts  |    1 +
 tests/e2e/04-recenter-positions.spec.ts       |  153 ++
 tests/e2e/05-optimizer-integration.spec.ts    |  177 +++
 tests/setup/stack.ts                          |    1 +
 38 files changed, 3793 insertions(+), 205 deletions(-)
 create mode 100644 .claude-code-supervisor.yml
 create mode 100755 .claude/hooks/supervisor/lib.sh
 create mode 100755 .claude/hooks/supervisor/on-error.sh
 create mode 100755 .claude/hooks/supervisor/on-notify.sh
 create mode 100755 .claude/hooks/supervisor/on-stop.sh
 create mode 100755 .claude/hooks/supervisor/triage.sh
 create mode 100644 .claude/settings.json
 create mode 100644 docs/DEPLOYMENT_RUNBOOK.md
 create mode 100644 onchain/src/OptimizerV2.sol
 create mode 100644 onchain/src/OptimizerV3.sol
 create mode 100644 onchain/test/EthScarcityAbundance.t.sol
 create mode 100644 onchain/test/FuzzingAnalyzerBugs.t.sol
 create mode 100644 onchain/test/OptimizerV3.t.sol
 create mode 100644 tests/e2e/04-recenter-positions.spec.ts
 create mode 100644 tests/e2e/05-optimizer-integration.spec.ts

diff --git a/.claude-code-supervisor.yml b/.claude-code-supervisor.yml
new file mode 100644
index 0000000..0328145
--- /dev/null
+++ b/.claude-code-supervisor.yml
@@ -0,0 +1,26 @@
+# Claude Code Supervisor configuration
+# Copy to ~/.config/claude-code-supervisor/config.yml
+# or .claude-code-supervisor.yml in your project root.
+
+triage:
+  # Command that accepts a prompt on stdin and returns text on stdout.
+  # Default: claude -p (uses Claude Code's own auth)
+  command: "claude -p --no-session-persistence"
+  model: "claude-haiku-4-20250414"
+  max_tokens: 150
+
+notify:
+  # Command that receives a JSON string as its last argument.
+  # Called when triage determines action is needed.
+  # Examples:
+  #   openclaw:  openclaw gateway call wake --params
+  #   ntfy:      curl -s -X POST https://ntfy.sh/my-topic -d
+  #   webhook:   curl -s -X POST https://example.com/hook -H 'Content-Type: application/json' -d
+  #   script:    /path/to/my-notify.sh
+  command: "openclaw gateway call wake --params"
+
+# Quiet hours — suppress non-urgent escalations
+quiet_hours:
+  start: "23:00"
+  end: "08:00"
+  timezone: "Europe/Berlin"
diff --git a/.claude/hooks/supervisor/lib.sh b/.claude/hooks/supervisor/lib.sh
new file mode 100755
index 0000000..68d3892
--- /dev/null
+++ b/.claude/hooks/supervisor/lib.sh
@@ -0,0 +1,139 @@
+#!/bin/bash
+# Shared functions for claude-code-supervisor hooks and scripts.
+
+set -euo pipefail
+
+# Find config file: project .claude-code-supervisor.yml → ~/.config/ → defaults
+ccs_find_config() {
+  local cwd="${1:-.}"
+  if [ -f "$cwd/.claude-code-supervisor.yml" ]; then
+    echo "$cwd/.claude-code-supervisor.yml"
+  elif [ -f "${HOME}/.config/claude-code-supervisor/config.yml" ]; then
+    echo "${HOME}/.config/claude-code-supervisor/config.yml"
+  else
+    echo ""
+  fi
+}
+
+# Read a yaml value (simple key.subkey extraction, no yq dependency).
+# Falls back to default if not found.
+ccs_config_get() {
+  local config_file="$1"
+  local key="$2"
+  local default="${3:-}"
+
+  if [ -z "$config_file" ] || [ ! -f "$config_file" ]; then
+    echo "$default"
+    return
+  fi
+
+  # Simple grep-based yaml extraction (handles key: value on one line)
+  local value
+  case "$key" in
+    triage.command)   value=$(grep -A0 '^\s*command:' "$config_file" | head -1 | sed 's/.*command:\s*["]*//;s/["]*$//' | xargs) ;;
+    triage.model)     value=$(awk '/^triage:/,/^[a-z]/' "$config_file" | grep 'model:' | head -1 | sed 's/.*model:\s*["]*//;s/["]*$//' | xargs) ;;
+    triage.max_tokens) value=$(awk '/^triage:/,/^[a-z]/' "$config_file" | grep 'max_tokens:' | head -1 | sed 's/.*max_tokens:\s*//' | xargs) ;;
+    notify.command)   value=$(awk '/^notify:/,/^[a-z]/' "$config_file" | grep 'command:' | head -1 | sed 's/.*command:\s*["]*//;s/["]*$//' | xargs) ;;
+    idle.timeout)     value=$(awk '/^idle:/,/^[a-z]/' "$config_file" | grep 'timeout_seconds:' | head -1 | sed 's/.*timeout_seconds:\s*//' | xargs) ;;
+    idle.nudge_message) value=$(awk '/^idle:/,/^[a-z]/' "$config_file" | grep 'nudge_message:' | head -1 | sed 's/.*nudge_message:\s*["]*//;s/["]*$//' | xargs) ;;
+    *)                value="" ;;
+  esac
+
+  echo "${value:-$default}"
+}
+
+# Send a notification via the configured notify command.
+ccs_notify() {
+  local config_file="$1"
+  local message="$2"
+
+  local notify_cmd
+  notify_cmd=$(ccs_config_get "$config_file" "notify.command" "openclaw gateway call wake --params")
+
+  # Build JSON payload
+  local payload
+  payload=$(jq -n --arg text "$message" --arg mode "now" '{text: $text, mode: $mode}')
+
+  $notify_cmd "$payload" 2>/dev/null || true
+}
+
+# Run LLM triage via configured command.
+# Accepts prompt on stdin, returns verdict on stdout.
+ccs_triage() {
+  local config_file="$1"
+  local prompt="$2"
+
+  local triage_cmd model max_tokens
+  triage_cmd=$(ccs_config_get "$config_file" "triage.command" "claude -p --no-session-persistence")
+  model=$(ccs_config_get "$config_file" "triage.model" "claude-haiku-4-20250414")
+  max_tokens=$(ccs_config_get "$config_file" "triage.max_tokens" "150")
+
+  echo "$prompt" | $triage_cmd --model "$model" --max-tokens "$max_tokens" 2>/dev/null
+}
+
+# Generate a notify wrapper script the agent can call on completion.
+# Usage: ccs_generate_notify_script "$config_file" ["/tmp/supervisor-notify.sh"]
+ccs_generate_notify_script() {
+  local config_file="$1"
+  local script_path="${2:-/tmp/supervisor-notify.sh}"
+  local notify_cmd
+  notify_cmd=$(ccs_config_get "$config_file" "notify.command" "openclaw gateway call wake --params")
+
+  cat > "$script_path" <<SCRIPT
+#!/bin/bash
+# Auto-generated by claude-code-supervisor
+# Usage: $script_path "your summary here"
+MESSAGE="\${*:-done}"
+PAYLOAD=\$(jq -n --arg text "cc-supervisor: DONE | agent-reported | \$MESSAGE" --arg mode "now" '{text: \$text, mode: \$mode}')
+$notify_cmd "\$PAYLOAD" 2>/dev/null || echo "Notify failed (command: $notify_cmd)" >&2
+SCRIPT
+  chmod +x "$script_path"
+}
+
+# Extract environment_hints from config as newline-separated list.
+# Usage: hints=$(ccs_environment_hints "$config_file")
+ccs_environment_hints() {
+  local config_file="$1"
+  if [ -z "$config_file" ] || [ ! -f "$config_file" ]; then
+    return
+  fi
+  awk '/^environment_hints:/,/^[a-z]/' "$config_file" \
+    | grep '^\s*-' \
+    | sed 's/^\s*-\s*["]*//;s/["]*$//'
+}
+
+# Parse capture-pane output and return session status.
+# Returns: WORKING | IDLE | DONE | ERROR
+# Usage: status=$(ccs_parse_status "$pane_output")
+ccs_parse_status() {
+  local output="$1"
+  local last_lines
+  last_lines=$(echo "$output" | tail -15)
+
+  # DONE: completed task indicators (cost summary line)
+  if echo "$last_lines" | grep -qE '(Brewed for|Churned for) [0-9]+'; then
+    echo "DONE"
+    return
+  fi
+
+  # WORKING: active tool call or thinking
+  if echo "$last_lines" | grep -qE 'esc to interrupt|Running…|Waiting…'; then
+    echo "WORKING"
+    return
+  fi
+
+  # ERROR: tool failures or API errors
+  if echo "$last_lines" | grep -qiE 'API Error:|Exit code [1-9]|^Error:'; then
+    echo "ERROR"
+    return
+  fi
+
+  # IDLE: prompt back with no activity indicator
+  if echo "$last_lines" | tail -3 | grep -qE '^\$ |^❯ |^% |^[a-z]+@.*\$ '; then
+    echo "IDLE"
+    return
+  fi
+
+  # Default: assume working (mid-output, streaming, etc.)
+  echo "WORKING"
+}
diff --git a/.claude/hooks/supervisor/on-error.sh b/.claude/hooks/supervisor/on-error.sh
new file mode 100755
index 0000000..acb55d3
--- /dev/null
+++ b/.claude/hooks/supervisor/on-error.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+# Claude Code PostToolUseFailure hook — fires when a tool call fails.
+#
+# Option D: bash pre-filter for known patterns, LLM triage for the rest.
+#
+# - API 500 → always triage (transient, likely needs nudge)
+# - API 429 → log + wait (rate limit, will resolve)
+# - Other tool errors → triage (might be important)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SUPERVISOR_DIR="${SCRIPT_DIR%/hooks}"
+
+INPUT=$(cat)
+
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // "unknown"')
+ERROR=$(echo "$INPUT" | jq -r '.error // .tool_error // "unknown"' | head -c 500)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+CWD=$(echo "$INPUT" | jq -r '.cwd // "unknown"')
+
+# Bash pre-filter
+if echo "$ERROR" | grep -qi "429\|rate.limit"; then
+  # Rate limited — log it, don't triage. It'll resolve.
+  echo "[$(date -u +%FT%TZ)] RATE_LIMITED | $TOOL | $CWD" >> "${CCS_LOG_FILE:-/tmp/ccs-triage.log}"
+  exit 0
+fi
+
+if echo "$ERROR" | grep -qi "500\|internal.server.error\|api_error"; then
+  # API 500 — high chance agent is stuck on this. Triage.
+  "$SUPERVISOR_DIR/triage.sh" "error:api_500" "$CWD" \
+    "Tool: $TOOL | Error: $ERROR | Session: $SESSION_ID" &
+  exit 0
+fi
+
+# Other errors — could be anything. Let LLM decide.
+"$SUPERVISOR_DIR/triage.sh" "error:$TOOL" "$CWD" \
+  "Tool: $TOOL | Error: $ERROR | Session: $SESSION_ID" &
+
+exit 0
diff --git a/.claude/hooks/supervisor/on-notify.sh b/.claude/hooks/supervisor/on-notify.sh
new file mode 100755
index 0000000..ca59998
--- /dev/null
+++ b/.claude/hooks/supervisor/on-notify.sh
@@ -0,0 +1,44 @@
+#!/bin/bash
+# Claude Code Notification hook — fires when Claude is waiting for input.
+#
+# Option D: bash pre-filter by notification type.
+#
+# - idle_prompt → triage (agent waiting, might need nudge)
+# - permission_prompt → always triage (might need approval)
+# - auth_* → skip (internal, transient)
+# - other → triage
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SUPERVISOR_DIR="${SCRIPT_DIR%/hooks}"
+
+INPUT=$(cat)
+
+NOTIFY_TYPE=$(echo "$INPUT" | jq -r '.type // "unknown"')
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+CWD=$(echo "$INPUT" | jq -r '.cwd // "unknown"')
+MESSAGE=$(echo "$INPUT" | jq -r '.message // ""' | head -c 300)
+
+case "$NOTIFY_TYPE" in
+  auth_*)
+    # Auth events are transient, skip
+    exit 0
+    ;;
+  permission_prompt)
+    # Agent needs permission — might be able to auto-approve, or escalate
+    "$SUPERVISOR_DIR/triage.sh" "notification:permission" "$CWD" \
+      "Permission requested: $MESSAGE | Session: $SESSION_ID" &
+    ;;
+  idle_prompt)
+    # Agent is idle, waiting for human input
+    "$SUPERVISOR_DIR/triage.sh" "notification:idle" "$CWD" \
+      "Agent idle, waiting for input. Message: $MESSAGE | Session: $SESSION_ID" &
+    ;;
+  *)
+    "$SUPERVISOR_DIR/triage.sh" "notification:$NOTIFY_TYPE" "$CWD" \
+      "Type: $NOTIFY_TYPE | Message: $MESSAGE | Session: $SESSION_ID" &
+    ;;
+esac
+
+exit 0
diff --git a/.claude/hooks/supervisor/on-stop.sh b/.claude/hooks/supervisor/on-stop.sh
new file mode 100755
index 0000000..27788d4
--- /dev/null
+++ b/.claude/hooks/supervisor/on-stop.sh
@@ -0,0 +1,71 @@
+#!/bin/bash
+# Claude Code Stop hook — fires when the agent finishes responding.
+#
+# Option D: bash pre-filter first, LLM triage only for ambiguous cases.
+#
+# Known Stop event fields:
+#   session_id, transcript_path, cwd, permission_mode,
+#   hook_event_name ("Stop"), stop_hook_active
+#
+# Note: stop_reason is NOT provided in the Stop event JSON.
+# We detect state by inspecting the tmux pane instead.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SUPERVISOR_DIR="${SCRIPT_DIR%/hooks}"
+
+INPUT=$(cat)
+
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+CWD=$(echo "$INPUT" | jq -r '.cwd // "unknown"')
+
+# Find matching supervised session
+STATE_FILE="${CCS_STATE_FILE:-${HOME}/.openclaw/workspace/supervisor-state.json}"
+if [ ! -f "$STATE_FILE" ]; then
+  exit 0  # No supervised sessions
+fi
+
+SOCKET=$(jq -r --arg cwd "$CWD" '
+  .sessions | to_entries[] | select(.value.projectDir == $cwd and .value.status == "running") | .value.socket
+' "$STATE_FILE" 2>/dev/null || echo "")
+
+TMUX_SESSION=$(jq -r --arg cwd "$CWD" '
+  .sessions | to_entries[] | select(.value.projectDir == $cwd and .value.status == "running") | .value.tmuxSession
+' "$STATE_FILE" 2>/dev/null || echo "")
+
+# No matching supervised session for this project
+if [ -z "$SOCKET" ] || [ -z "$TMUX_SESSION" ]; then
+  exit 0
+fi
+
+# Can we reach the tmux session?
+if [ ! -S "$SOCKET" ] || ! tmux -S "$SOCKET" has-session -t "$TMUX_SESSION" 2>/dev/null; then
+  exit 0
+fi
+
+PANE_OUTPUT=$(tmux -S "$SOCKET" capture-pane -p -J -t "$TMUX_SESSION" -S -30 2>/dev/null || echo "")
+
+# Bash pre-filter: check the last few lines for patterns
+
+# Check for API errors (transient — always triage)
+if echo "$PANE_OUTPUT" | tail -10 | grep -qiE "API Error: 5[0-9][0-9]|internal.server.error|api_error"; then
+  "$SUPERVISOR_DIR/triage.sh" "stopped:api_error" "$CWD" "$PANE_OUTPUT" &
+  exit 0
+fi
+
+# Check for rate limiting
+if echo "$PANE_OUTPUT" | tail -10 | grep -qiE "429|rate.limit"; then
+  echo "[$(date -u +%FT%TZ)] RATE_LIMITED | stop | $CWD" >> "${CCS_LOG_FILE:-/tmp/ccs-triage.log}"
+  exit 0
+fi
+
+# Check if shell prompt is back (Claude Code exited)
+if echo "$PANE_OUTPUT" | tail -5 | grep -qE '^\$ |^❯ [^/]|^% |^[a-z]+@.*\$ '; then
+  # Prompt returned — agent might be done or crashed. Triage it.
+  "$SUPERVISOR_DIR/triage.sh" "stopped:prompt_back" "$CWD" "$PANE_OUTPUT" &
+  exit 0
+fi
+
+# No prompt back, no errors — agent is likely mid-conversation. Skip silently.
+exit 0
diff --git a/.claude/hooks/supervisor/triage.sh b/.claude/hooks/supervisor/triage.sh
new file mode 100755
index 0000000..31200a7
--- /dev/null
+++ b/.claude/hooks/supervisor/triage.sh
@@ -0,0 +1,72 @@
+#!/bin/bash
+# Triage a Claude Code event using a fast LLM.
+# Called by hook scripts when bash pre-filtering can't decide.
+#
+# Usage: triage.sh <event-type> <cwd> <context>
+#   event-type: stopped | error | notification
+#   cwd: project directory (used to find config + state)
+#   context: the relevant context (tmux output, error message, etc.)
+#
+# Reads supervisor-state.json to find the goal for this session.
+# Returns one of: FINE | NEEDS_NUDGE | STUCK | DONE | ESCALATE
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+source "$SCRIPT_DIR/lib.sh"
+
+EVENT_TYPE="${1:-unknown}"
+CWD="${2:-.}"
+CONTEXT="${3:-}"
+
+CONFIG=$(ccs_find_config "$CWD")
+
+# Try to find the goal from supervisor state
+STATE_FILE="${CCS_STATE_FILE:-${HOME}/.openclaw/workspace/supervisor-state.json}"
+GOAL="unknown"
+if [ -f "$STATE_FILE" ]; then
+  # Match by cwd/projectDir
+  GOAL=$(jq -r --arg cwd "$CWD" '
+    .sessions | to_entries[] | select(.value.projectDir == $cwd) | .value.goal
+  ' "$STATE_FILE" 2>/dev/null || echo "unknown")
+fi
+
+PROMPT="You are a coding agent supervisor. A Claude Code session just triggered an event.
+
+Event: ${EVENT_TYPE}
+Project: ${CWD}
+Goal: ${GOAL}
+
+Recent terminal output:
+${CONTEXT}
+
+Classify this situation with exactly one word on the first line:
+  FINE - Agent is working normally, no intervention needed
+  NEEDS_NUDGE - Agent hit a transient error or stopped prematurely, should be told to continue
+  STUCK - Agent is looping or not making progress, needs different approach
+  DONE - Agent completed the task successfully
+  ESCALATE - Situation needs human judgment
+
+Then a one-line explanation."
+
+VERDICT=$(ccs_triage "$CONFIG" "$PROMPT")
+
+echo "$VERDICT"
+
+# Extract the classification (first word of first line)
+CLASSIFICATION=$(echo "$VERDICT" | head -1 | awk '{print $1}')
+
+# Only notify if action is needed
+case "$CLASSIFICATION" in
+  FINE)
+    # Log silently, don't wake anyone
+    echo "[$(date -u +%FT%TZ)] FINE | $EVENT_TYPE | $CWD" >> "${CCS_LOG_FILE:-/tmp/ccs-triage.log}"
+    ;;
+  NEEDS_NUDGE|STUCK|DONE|ESCALATE)
+    ccs_notify "$CONFIG" "cc-supervisor: $CLASSIFICATION | $EVENT_TYPE | cwd=$CWD | $VERDICT"
+    ;;
+  *)
+    # Couldn't parse — notify to be safe
+    ccs_notify "$CONFIG" "cc-supervisor: UNKNOWN | $EVENT_TYPE | cwd=$CWD | verdict=$VERDICT"
+    ;;
+esac
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 0000000..15f555e
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,37 @@
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/home/debian/harb/.claude/hooks/supervisor/on-stop.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/home/debian/harb/.claude/hooks/supervisor/on-error.sh"
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/home/debian/harb/.claude/hooks/supervisor/on-notify.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/.husky/pre-commit b/.husky/pre-commit
index 2701dce..a28a48f 100755
--- a/.husky/pre-commit
+++ b/.husky/pre-commit
@@ -21,8 +21,9 @@ if [ -f "onchain/src/Kraiken.sol" ] && [ -f "kraiken-lib/src/version.ts" ]; then
       echo "  Library VERSION: $LIB_VERSION"
       echo "  Compatible versions: $COMPATIBLE"
 
-      # Check if contract version is in compatible list
-      if echo ",$COMPATIBLE," | grep -q ",$CONTRACT_VERSION,"; then
+      # Check if contract version is in compatible list (strip spaces for reliable matching)
+      COMPATIBLE_CLEAN=$(echo "$COMPATIBLE" | tr -d ' ')
+      if echo ",$COMPATIBLE_CLEAN," | grep -q ",$CONTRACT_VERSION,"; then
         echo "  ✓ Version sync validated"
       else
         echo "  ❌ Version validation failed!"
diff --git a/TECHNICAL_APPENDIX.md b/TECHNICAL_APPENDIX.md
index 8fdded0..41dbcd3 100644
--- a/TECHNICAL_APPENDIX.md
+++ b/TECHNICAL_APPENDIX.md
@@ -51,11 +51,24 @@ Double-overflow scenarios requiring >1000x compression would need:
 - **Conclusion**: 1000x compression limit provides adequate protection against realistic scenarios
 
 ### Implementation Details
-**FLOOR Position Calculation:**
+**FLOOR Position Calculation (Unified Formula):**
 ```
-FLOOR_PRICE = VWAP_PRICE * (0.7 + CAPITAL_INEFFICIENCY)
+floorTick = max(scarcityTick, mirrorTick, clampTick) toward KRK-cheap side
 ```
 
+Three signals determine the floor:
+- **scarcityTick**: derived from `vwapX96` and ETH/supply ratio. Dominates when ETH is scarce.
+- **mirrorTick**: `currentTick + |adjustedVwapTick - currentTick|` on KRK-cheap side. Reflects VWAP distance symmetrically. During sell pressure the mirror distance grows, resisting floor walkdown.
+- **clampTick**: minimum distance from anchor edge. `anchorSpacing = 200 + (34 × 20 × AW / 100)` ticks.
+
+**VWAP Mirror Defense:**
+- During sell-heavy trading, the current tick drops but VWAP stays higher, so mirror distance *grows* — floor naturally resists being walked down.
+- CI controls mirror distance through `getAdjustedVWAP(CI)` with no magic numbers. CI=0% is safest (proven zero effect on fee revenue).
+
+**Directional VWAP Recording:**
+- VWAP only records on ETH inflow (buys into the LM), preventing attackers from diluting VWAP with sells.
+- `shouldRecordVWAP` compares `lastRecenterTick` to current tick to detect direction.
+
 **Protection Mechanism:**
 - VWAP provides "eternal memory" of historical trading activity
 - Compression algorithm ensures memory persists even under extreme volume
@@ -76,26 +89,26 @@ FLOOR_PRICE = VWAP_PRICE * (0.7 + CAPITAL_INEFFICIENCY)
 - **Average Tax Rate**: Weighted average of all staking tax rates
 - **Tax Rate Distribution**: Spread of tax rates across stakers
 
-### Optimizer Integration
-**Sentiment Analysis:**
-```solidity
-function getLiquidityParams() returns (
-    uint256 capitalInefficiency,
-    uint256 anchorShare,
-    uint24 anchorWidth,
-    uint256 discoveryDepth
-) {
-    // Analyze staking data to determine optimal liquidity parameters
-    // Higher confidence (tax rates) → more aggressive positioning
-    // Lower confidence → more conservative positioning
-}
-```
+### OptimizerV3 Integration
+**Direct 2D Binary Mapping (no intermediate score):**
+
+OptimizerV3 reads `percentageStaked` and `averageTaxRate` from the Stake contract and maps them directly to one of two configurations:
+
+- `staked ≤ 91%` → always **BEAR**: AS=30%, AW=100, CI=0, DD=0.3e18
+- `staked > 91%` → **BULL** if `deltaS³ × effIdx / 20 < 50`: AS=100%, AW=20, CI=0, DD=1e18
+
+The binary step avoids the AW 40-80 kill zone where intermediate parameters are exploitable. Bull requires >91% staked with low enough tax; any decline snaps to bear instantly.
+
+**Parameter Safety (proven via 1050-combo 4D sweep):**
+- CI=0% always (zero effect on fee revenue, maximum protection)
+- Fee revenue is parameter-independent (~1.5 ETH/cycle across all combos)
+- Safety comes entirely from the AS×AW configuration
 
 ### Economic Incentives
 - **Tax Revenue**: Funds protocol operations and incentivizes participation
 - **Staking Benefits**: Percentage ownership of total supply (rather than fixed token amounts)
 - **Prediction Market**: Tax rates create market-based sentiment signals
-- **Liquidity Optimization**: Sentiment data feeds into dynamic parameter adjustment
+- **Liquidity Optimization**: Sentiment data feeds into binary bear/bull parameter selection
 
 ## Position Dependencies Technical Details
 
@@ -130,7 +143,7 @@ function getLiquidityParams() returns (
 ### Key Contracts
 - **LiquidityManager.sol**: Core three-position strategy implementation
 - **VWAPTracker.sol**: Historical price memory and compression algorithm
-- **Optimizer.sol**: Sentiment analysis and parameter optimization
+- **OptimizerV3.sol**: Sentiment-driven binary bear/bull parameter selection (UUPS upgradeable)
 - **Stake.sol**: Harberger tax mechanism and sentiment data collection
 
 ### Analysis Tools
diff --git a/docs/DEPLOYMENT_RUNBOOK.md b/docs/DEPLOYMENT_RUNBOOK.md
new file mode 100644
index 0000000..8eae9df
--- /dev/null
+++ b/docs/DEPLOYMENT_RUNBOOK.md
@@ -0,0 +1,306 @@
+# KRAIKEN Mainnet Deployment Runbook
+
+**Target chain:** Base (L2)
+**Contract version:** V2 (OptimizerV3 w/ directional VWAP)
+
+---
+
+## 1. Pre-Deployment Checklist
+
+- [ ] All tests pass: `cd onchain && forge test`
+- [ ] Gas snapshot baseline: `forge snapshot`
+- [ ] Security review complete (see `analysis/SECURITY_REVIEW.md`)
+- [ ] Storage layout verified for UUPS upgrade (see `analysis/STORAGE_LAYOUT.md`)
+- [ ] Floor ratchet mitigation status confirmed (branch `fix/floor-ratchet`)
+- [ ] Multisig wallet ready for `feeDestination` (Gnosis Safe on Base)
+- [ ] Deployer wallet funded with sufficient ETH for gas (~0.05 ETH)
+- [ ] LiquidityManager funding wallet ready (initial ETH seed for pool positions)
+- [ ] `.secret` seed phrase file present in `onchain/` (deployer account)
+- [ ] Base RPC endpoint configured and tested
+- [ ] Etherscan/Basescan API key ready for contract verification
+- [ ] kraiken-lib version updated: `COMPATIBLE_CONTRACT_VERSIONS` includes `2`
+
+---
+
+## 2. Contract Deployment Order
+
+All contracts are deployed in a single broadcast transaction via `DeployBaseMainnet.sol`:
+
+```
+1. Kraiken token (ERC20 + ERC20Permit)
+2. Stake contract (Kraiken address, feeDestination)
+3. Kraiken.setStakingPool(Stake)
+4. Uniswap V3 Pool (create or use existing, FEE=10000)
+5. Pool initialization (1 cent starting price)
+6. OptimizerV3 implementation + ERC1967Proxy
+7. LiquidityManager (factory, WETH, Kraiken, OptimizerProxy)
+8. LiquidityManager.setFeeDestination(multisig)
+9. Kraiken.setLiquidityManager(LiquidityManager)
+```
+
+### Deploy Command
+
+```bash
+cd onchain
+
+# Verify configuration first
+cat script/DeployBaseMainnet.sol  # Check feeDest, weth, v3Factory
+
+# Dry run (no broadcast)
+forge script script/DeployBaseMainnet.sol \
+  --rpc-url $BASE_RPC \
+  --sender $(cast wallet address --mnemonic "$(cat .secret)")
+
+# Live deployment
+forge script script/DeployBaseMainnet.sol \
+  --rpc-url $BASE_RPC \
+  --broadcast \
+  --verify \
+  --etherscan-api-key $BASESCAN_API_KEY \
+  --slow
+```
+
+**Critical:** The `--slow` flag submits transactions one at a time, waiting for confirmation. This prevents nonce issues on Base.
+
+### Record Deployment Addresses
+
+After deployment, save all addresses from console output:
+```bash
+# Update deployments file
+cat >> deployments-mainnet.json << 'EOF'
+{
+  "chain": "base",
+  "chainId": 8453,
+  "kraiken": "0x...",
+  "stake": "0x...",
+  "pool": "0x...",
+  "liquidityManager": "0x...",
+  "optimizerProxy": "0x...",
+  "optimizerImpl": "0x...",
+  "feeDestination": "0x...",
+  "deployer": "0x...",
+  "deployedAt": "2026-XX-XX",
+  "txHash": "0x..."
+}
+EOF
+```
+
+---
+
+## 3. Post-Deployment Setup
+
+### 3.1 Fund LiquidityManager
+
+The LM needs ETH to create initial positions:
+
+```bash
+# Send ETH to LiquidityManager (unwrapped — it will wrap to WETH internally)
+cast send $LIQUIDITY_MANAGER --value 10ether \
+  --rpc-url $BASE_RPC \
+  --mnemonic "$(cat .secret)"
+```
+
+### 3.2 Set Recenter Access
+
+Restrict `recenter()` to the txnBot address:
+
+```bash
+# Must be called by feeDestination (multisig)
+cast send $LIQUIDITY_MANAGER "setRecenterAccess(address)" $TXNBOT_ADDRESS \
+  --rpc-url $BASE_RPC \
+  --mnemonic "$(cat .secret)"  # or via multisig
+```
+
+### 3.3 Trigger First Recenter
+
+```bash
+# Wait for pool to accumulate some TWAP history (~5 minutes of trades)
+# Then trigger first recenter (must be called by recenterAccess)
+cast send $LIQUIDITY_MANAGER "recenter()" \
+  --rpc-url $BASE_RPC \
+  --from $TXNBOT_ADDRESS
+```
+
+### 3.4 Configure txnBot
+
+Update `services/txnBot/` configuration for Base mainnet:
+- Set `LIQUIDITY_MANAGER` address
+- Set `KRAIKEN` address
+- Set RPC to Base mainnet
+- Deploy txnBot service
+
+### 3.5 Configure Ponder Indexer
+
+```bash
+# Update kraiken-lib/src/version.ts
+export const COMPATIBLE_CONTRACT_VERSIONS = [2];
+
+# Update Ponder config for Base mainnet addresses
+# Set PONDER_NETWORK=BASE in environment
+```
+
+### 3.6 Update Frontend
+
+- Update contract addresses in web-app configuration
+- Update kraiken-lib ABIs: `cd onchain && forge build` then rebuild kraiken-lib
+- Deploy frontend to production
+
+---
+
+## 4. Optimizer Upgrade Procedure
+
+If upgrading an existing Optimizer proxy to OptimizerV3:
+
+```bash
+cd onchain
+
+# Set proxy address
+export OPTIMIZER_PROXY=0x...
+
+# Dry run
+forge script script/UpgradeOptimizer.sol \
+  --rpc-url $BASE_RPC
+
+# Execute upgrade
+forge script script/UpgradeOptimizer.sol \
+  --rpc-url $BASE_RPC \
+  --broadcast \
+  --verify \
+  --etherscan-api-key $BASESCAN_API_KEY
+
+# Verify post-upgrade
+cast call $OPTIMIZER_PROXY "getLiquidityParams()" --rpc-url $BASE_RPC
+```
+
+**Expected output:** Bear-mode defaults (CI=0, AS=0.3e18, AW=100, DD=0.3e18) since staking will be <91%.
+
+---
+
+## 5. Verification Steps
+
+Run these checks after deployment to confirm everything is wired correctly:
+
+```bash
+# 1. Kraiken token
+cast call $KRAIKEN "VERSION()" --rpc-url $BASE_RPC          # Should return 2
+cast call $KRAIKEN "peripheryContracts()" --rpc-url $BASE_RPC  # LM + Stake addresses
+
+# 2. LiquidityManager
+cast call $LM "feeDestination()" --rpc-url $BASE_RPC       # Should be multisig
+cast call $LM "recenterAccess()" --rpc-url $BASE_RPC       # Should be txnBot
+cast call $LM "positions(0)" --rpc-url $BASE_RPC           # Floor position (after recenter)
+cast call $LM "positions(1)" --rpc-url $BASE_RPC           # Anchor position
+cast call $LM "positions(2)" --rpc-url $BASE_RPC           # Discovery position
+
+# 3. OptimizerV3 (through proxy)
+cast call $OPTIMIZER "getLiquidityParams()" --rpc-url $BASE_RPC
+
+# 4. Pool state
+cast call $POOL "slot0()" --rpc-url $BASE_RPC              # Current tick, price
+cast call $POOL "liquidity()" --rpc-url $BASE_RPC          # Total liquidity
+
+# 5. Stake contract
+cast call $STAKE "nextPositionId()" --rpc-url $BASE_RPC    # Should be 0 initially
+
+# 6. ETH balance
+cast balance $LM --rpc-url $BASE_RPC                       # Should show funded amount
+```
+
+---
+
+## 6. Emergency Procedures
+
+### 6.1 Pause Recentering
+
+**WARNING:** `revokeRecenterAccess()` does NOT pause recentering. It makes `recenter()` permissionless (anyone can call it with 60-second cooldown + TWAP check). In an attack scenario, this would make things worse.
+
+To truly lock out recenters, set `recenterAccess` to a burn address that no one controls:
+
+```bash
+# Called by feeDestination (multisig) — sets access to a dead address
+cast send $LM "setRecenterAccess(address)" 0x000000000000000000000000000000000000dEaD \
+  --rpc-url $BASE_RPC
+```
+
+This leaves existing positions in place but prevents any new recenters. LP positions continue earning fees. To resume, call `setRecenterAccess()` with the txnBot address again.
+
+### 6.2 Upgrade Optimizer to Safe Defaults
+
+Deploy a minimal "safe" optimizer that always returns bear parameters:
+
+```bash
+# Deploy SafeOptimizer with hardcoded bear params
+# Upgrade proxy to SafeOptimizer
+OPTIMIZER_PROXY=$OPTIMIZER forge script script/UpgradeOptimizer.sol \
+  --rpc-url $BASE_RPC --broadcast
+```
+
+### 6.3 Emergency Parameter Override
+
+If the optimizer needs temporary override, deploy a new implementation with hardcoded safe parameters:
+- CI=0, AS=30% (0.3e18), AW=100, DD=0.3e18 (bear defaults)
+- These were verified safe across all 1050 parameter sweep combinations
+
+### 6.4 Rollback Plan
+
+**There is no rollback for deployed contracts.** Mitigation options:
+- Upgrade optimizer proxy to revert to V1/V2 logic
+- Revoke recenter access to freeze positions
+- The LiquidityManager itself is NOT upgradeable (by design — immutable control)
+- In worst case: deploy entirely new contract set, migrate liquidity
+
+### 6.5 Known Attack Response: Floor Ratchet
+
+If floor ratchet extraction is detected (rapid recenters + floor tick creeping toward current price):
+1. **Immediately** set recenter access to burn address (`0xdEaD`) — do NOT use `revokeRecenterAccess()` as it makes recenter permissionless
+2. Assess floor position state via `positions(0)`
+3. Deploy patched LiquidityManager if fix is ready
+4. Current mitigation: bear-mode parameters (AW=100) create 7000-tick floor distance, making ratchet extraction significantly harder
+
+---
+
+## 7. Monitoring Setup
+
+### On-Chain Monitoring
+
+Track these metrics via Ponder or direct RPC polling:
+
+| Metric | How | Alert Threshold |
+|--------|-----|-----------------|
+| Floor tick distance | `positions(0).tickLower - currentTick` | < 2000 ticks |
+| Recenter frequency | Count `recenter()` calls per hour | > 10/hour |
+| LM ETH balance | `address(LM).balance + WETH.balanceOf(LM)` | < 1 ETH (most ETH is in pool positions) |
+| VWAP drift | `getVWAP()` vs current price | > 50% divergence |
+| Optimizer mode | `getLiquidityParams()` return values | Unexpected bull in low-staking |
+| Fee revenue | WETH transfers to feeDestination | Sudden drop to 0 |
+
+### Off-Chain Monitoring
+
+- txnBot health: `GET /api/txn/status` — should return healthy
+- Ponder indexing: `GET /api/graphql` — query `stats` entity
+- Frontend version check: `useVersionCheck()` composable validates contract VERSION
+
+### Alerting Triggers
+
+1. **Critical:** Floor position liquidity = 0 (no floor protection)
+2. **Critical:** recenter() reverts for > 1 hour
+3. **High:** > 20 recenters in 1 hour (potential manipulation)
+4. **Medium:** VWAP compression triggered (high cumulative volume)
+5. **Low:** Optimizer returns bull mode (verify staking metrics justify it)
+
+---
+
+## 8. Deployment Timeline
+
+| Step | Duration | Dependency |
+|------|----------|------------|
+| Deploy contracts | ~2 min | Funded deployer wallet |
+| Verify on Basescan | ~5 min | Deployment complete |
+| Fund LiquidityManager | ~1 min | Deployment complete |
+| Set recenter access | ~1 min | feeDestination set (multisig) |
+| Wait for TWAP history | ~5-10 min | Pool initialized |
+| First recenter | ~1 min | TWAP history + recenter access |
+| Deploy txnBot | ~5 min | Addresses configured |
+| Deploy Ponder | ~10 min | Addresses + kraiken-lib updated |
+| Deploy frontend | ~5 min | Ponder running |
+| **Total** | **~30-40 min** | |
diff --git a/kraiken-lib/src/version.ts b/kraiken-lib/src/version.ts
index 9d88a5f..965d835 100644
--- a/kraiken-lib/src/version.ts
+++ b/kraiken-lib/src/version.ts
@@ -9,7 +9,7 @@
  * Current version this library is built for.
  * Should match the deployed Kraiken contract VERSION.
  */
-export const KRAIKEN_LIB_VERSION = 1;
+export const KRAIKEN_LIB_VERSION = 2;
 
 /**
  * Singleton ID used for stack metadata rows across services.
@@ -24,8 +24,9 @@ export const STACK_META_ID = 'stack-meta';
  *
  * Version History:
  * - v1: Initial deployment (30-tier TAX_RATES, index-based staking)
+ * - v2: OptimizerV3, VWAP mirror floor, directional VWAP recording
  */
-export const COMPATIBLE_CONTRACT_VERSIONS = [1];
+export const COMPATIBLE_CONTRACT_VERSIONS = [1, 2];
 
 /**
  * Validates if a contract version is compatible with this library.
diff --git a/landing/src/views/docs/AiAgent.vue b/landing/src/views/docs/AiAgent.vue
index 417253d..a95ab46 100644
--- a/landing/src/views/docs/AiAgent.vue
+++ b/landing/src/views/docs/AiAgent.vue
@@ -125,78 +125,81 @@
       </li>
     </ol>
 
-    <h2>Agent Contract</h2>
+    <h2>Optimizer Contract</h2>
     <p>
-      The Agent Contract serves as the execution layer for the AI agent, interfacing directly with the liquidity manager contract. It is
-      invoked periodically by the liquidity manager to collect input data, run the genetic algorithm, and return actionable outputs for
-      liquidity adjustments. The Agent Contract performs the following key functions:
+      The Optimizer Contract (OptimizerV3) serves as the decision layer for the AI agent, interfacing directly with the liquidity manager
+      contract. It is queried during every rebalance to determine how liquidity should be positioned. The Optimizer uses a direct 2D mapping
+      from on-chain staking sentiment to binary bear/bull configurations:
     </p>
     <ol>
       <li>
-        <strong>Input Collection and Preprocessing:</strong>
+        <strong>Sentiment Signal Collection:</strong>
         <ul>
           <li>
-            The contract gathers all necessary data points, such as price position, volatility ratio, volume-to-liquidity ratio, percentage
-            staked, and average tax rate.
+            The contract reads two key signals directly from the Harberger staking system: the percentage of staking slots currently
+            utilized, and the average tax rate across all active stakers.
           </li>
-          <li>These inputs are normalized and placed onto the stack of the Push3 Virtual Machine (VM) for efficient computation.</li>
+          <li>These signals together form a real-time sentiment indicator that captures community conviction.</li>
         </ul>
       </li>
       <li>
-        <strong>Algorithm Loading:</strong>
+        <strong>Bear/Bull Classification:</strong>
         <ul>
-          <li>The genetic algorithm, stored within the contract’s state, is loaded and also placed onto the stack of the Push3 VM.</li>
-          <li>This setup initializes the VM for execution.</li>
+          <li>When staking utilization is at or below 91%, the optimizer always selects the defensive <strong>bear</strong> configuration. This represents the vast majority (~94%) of the staking state space.</li>
+          <li>Bull mode requires both very high staking (&gt;91%) <em>and</em> low average tax rates &mdash; a signal of genuine community euphoria rather than speculative over-bidding.</li>
+          <li>Any decline in staking instantly snaps the system back to bear mode, providing rapid downside protection.</li>
         </ul>
       </li>
       <li>
-        <strong>Execution and Output Retrieval:</strong>
+        <strong>Binary Parameter Output:</strong>
         <ul>
-          <li>The Push3 VM executes the genetic algorithm using the input parameters on the stack.</li>
-          <li>
-            The execution results in a set of outputs, which may include adjustments to liquidity parameters or a non-action signal
-            indicating no immediate changes are necessary.
-          </li>
+          <li><strong>Bear mode:</strong> Conservative anchor (30% of ETH, wide 100-tick range), minimal discovery. Maximizes floor protection.</li>
+          <li><strong>Bull mode:</strong> Aggressive anchor (100% of ETH, narrow 20-tick range), full discovery depth. Maximizes fee capture during euphoria.</li>
+          <li>The binary step avoids intermediate parameter ranges that were found to be exploitable during extensive fuzzing and adversarial testing.</li>
         </ul>
       </li>
       <li>
-        <strong>Forwarding Outputs to Liquidity Manager:</strong>
+        <strong>Forwarding to Liquidity Manager:</strong>
         <ul>
           <li>
-            The outputs are forwarded to the liquidity manager contract, which applies the recommended changes to reposition liquidity if
-            necessary.
+            The outputs are forwarded to the liquidity manager contract, which applies the recommended changes to reposition liquidity
+            during the next rebalance.
           </li>
         </ul>
       </li>
     </ol>
 
     <p>
-      By introducing the Agent Contract, the previously static liquidity manager becomes capable of real-time optimization, driven by
-      on-chain evolutionary computation. If you want to know how genetic algorithms work, or why the system is considered an agent, read
-      this <a href="https://github.com/Sovraigns/SoLUSH-3/blob/main/vision.md">vision document</a>.
+      The Optimizer is upgradeable via UUPS proxy pattern, allowing the sentiment-to-parameter mapping to evolve as the protocol gathers
+      more real-world data. However, the core Liquidity Manager remains immutable &mdash; the Optimizer can only influence <em>how</em>
+      liquidity is positioned, never the fundamental safety guarantees of the protocol.
     </p>
 
-    <h2>Dynamic Adaptation Through AI</h2>
+    <h2>Dynamic Adaptation Through Sentiment</h2>
     <p>
-      The AI agent’s ability to dynamically adapt parameters allows the liquidity manager to respond to market volatility, trading volume,
-      and user behavior in real-time. For example:
+      The Optimizer's ability to read staking sentiment and adapt parameters allows the liquidity manager to respond to community conviction
+      in real-time. The system naturally traces a cycle through three phases:
     </p>
     <ul>
       <li>
-        <strong>Volatile Markets:</strong> The agent can widen Anchor and Discovery spacing to reduce exposure and maintain stability.
+        <strong>Bear Mode (Default):</strong> With staking below 91%, the Optimizer maintains a wide, conservative anchor and minimal
+        discovery. The Floor is maximally protected, and the protocol prioritizes solvency over aggressive fee capture.
       </li>
-      <li><strong>High Volume:</strong> The agent can increase liquidity in Discovery to capture more trading fees.</li>
       <li>
-        <strong>User Engagement:</strong> High staking utilization might lead the agent to prioritize profitability over conservatism.
+        <strong>Bull Transition:</strong> As staking fills past 91% with low tax rates &mdash; a signal of genuine community euphoria
+        &mdash; the Optimizer switches to an aggressive configuration. The narrow anchor concentrates liquidity near the current price,
+        maximizing trading fee revenue during periods of high activity.
+      </li>
+      <li>
+        <strong>Snap-Back Protection:</strong> Any decline in staking instantly reverts to bear mode. The cubic sensitivity ensures that
+        even a small 4-6% drop in staking triggers the transition, providing rapid downside protection.
       </li>
     </ul>
 
     <p>
-      By replacing static configurations with adaptive intelligence, the liquidity manager evolves into a dynamic system capable of
-      optimizing for diverse and changing conditions. This integration enables a more resilient and efficient approach to decentralized
-      liquidity management, where the AI agent collaborates with stakers to form a cybernetic system. Staking signals, such as the
-      percentage staked and the average tax rate, provide critical real-time sentiment data that the agent uses to refine its decisions and
-      adapt dynamically to market behaviors.
+      By replacing static configurations with sentiment-driven adaptation, the liquidity manager evolves into a dynamic system that responds
+      to community behavior. Staking signals provide critical real-time sentiment data, creating a cybernetic feedback loop: stakers
+      influence liquidity positioning through their commitment, and the resulting market dynamics in turn affect staking incentives.
     </p>
   </div>
 </template>
diff --git a/landing/src/views/docs/FaqDocs.vue b/landing/src/views/docs/FaqDocs.vue
index 928d62d..b65d4c7 100644
--- a/landing/src/views/docs/FaqDocs.vue
+++ b/landing/src/views/docs/FaqDocs.vue
@@ -34,11 +34,12 @@
     <h3>Are there any fees when using the protocol?</h3>
     <p>There are no fees and there is no fee switch. Kraiken is an immutable protocol that has been fair launched and will continue so.</p>
     <h3>How can I stake my $KRK?</h3>
-    <p>You can get access to staking by contacting the team.</p>
+    <p>You can stake your $KRK tokens at <a href="https://kraiken.org">kraiken.org</a> by connecting your wallet and selecting a tax rate.</p>
     <h3>Can the protocol code be changed later?</h3>
     <p>
-      No – All contracts are permanently immutable after deployment. Liquidity Manager and AI agent operate autonomously with no upgrade
-      path or admin controls.
+      The core contracts (Liquidity Manager, Token, Staking) are permanently immutable after deployment with no admin controls. The
+      Optimizer, which determines liquidity positioning parameters based on staking sentiment, is upgradeable via a UUPS proxy to allow the
+      sentiment-to-parameter mapping to evolve as the protocol gathers real-world data.
     </p>
     <h3>Are there team allocations or unlocks?</h3>
     <p>
diff --git a/landing/src/views/docs/HarbergerTax.vue b/landing/src/views/docs/HarbergerTax.vue
index 1781a2b..5b6af63 100644
--- a/landing/src/views/docs/HarbergerTax.vue
+++ b/landing/src/views/docs/HarbergerTax.vue
@@ -10,16 +10,14 @@
     <h2 id="second">Implementation in the Crypto Context</h2>
     <p>
       In crypto, limited assets or positions are often held by a select few without options for redistributing ownership—examples include
-      early investors, protocol teams, fee distributions, multisig holders, NFT owners etc. The HARBERG protocol aims to challenge the
+      early investors, protocol teams, fee distributions, multisig holders, NFT owners etc. The KrAIken protocol aims to challenge the
       current model of protocol ownership and test an alternative approach.
     </p>
     <h2 id="third">Key Differences</h2>
     <p>
-      In the traditional model, the value of the asset is constantly changeable to reflect the current market value and dynamics. In the
-      HARBERG protocol, the tax rate is constantly changeable, and owners must evaluate it regularly to retain their ownership positions.
+      In the traditional model, the value of the asset is constantly changeable to reflect the current market value and dynamics. In
+      KrAIken, the tax rate is constantly changeable, and owners must evaluate it regularly to retain their ownership positions.
     </p>
-    <h3>Read More:</h3>
-    <p>See <a href="website.org">Harberger Tax Blog Post</a> or <a href="website.org">Owner Tax</a></p>
   </div>
 </template>
 
diff --git a/landing/src/views/docs/HoldersDocs.vue b/landing/src/views/docs/HoldersDocs.vue
index 62d1eca..5bdc75e 100644
--- a/landing/src/views/docs/HoldersDocs.vue
+++ b/landing/src/views/docs/HoldersDocs.vue
@@ -2,28 +2,28 @@
   <div>
     <h1 id="first">Generate Passive Income</h1>
     <p>
-      In traditional protocol designs, holders benefit from a protocol’s success only indirectly through an increase in token price. HARBERG
+      In traditional protocol designs, holders benefit from a protocol's success only indirectly through an increase in token price. KrAIken
       changes this by allowing holders to earn directly through a passive income stream funded by protocol owners, who pay for the privilege
       of staying in their positions of power.
     </p>
     <br />
     <p>
-      Token holders are essential for decentralisation, governance and decision-making in crypto. Their role is key to a project’s long-term
-      success. It’s only fair that token holders should have the right to become owners of the very protocol they support.
+      Token holders are essential for decentralisation, governance and decision-making in crypto. Their role is key to a project's long-term
+      success. It's only fair that token holders should have the right to become owners of the very protocol they support.
     </p>
-    <h2 id="second">Buy $HARB</h2>
+    <h2 id="second">Buy $KRK</h2>
     <p>
-      $HARB tokens and the Harberg Protocol are deployed on Base an $ETHeum Layer 2. $HARB can be bought on
-      <a href="uniswap.org">Uniswap</a> there.
+      $KRK tokens and the KrAIken Protocol are deployed on Base, an Ethereum Layer 2. $KRK can be bought on
+      <a href="https://uniswap.org">Uniswap</a> there.
     </p>
     <h2 id="third">Passive Income</h2>
     <p>
-      By holding $HARB, holders can claim a passive income funded by the owner’s tax. The more owners are competing for limited owner slots
+      By holding $KRK, holders can claim a passive income funded by the owner's tax. The more owners are competing for limited owner slots
       the higher the tax for the token holders.
     </p>
     <p>The longer the token is held, the more tax holders can claim. No protocol fee is taken.</p>
-    <h2 id="fourth">Sell $HARB</h2>
-    <p>$HARB can be sold anytime on <a href="uniswap.org">Uniswap</a></p>
+    <h2 id="fourth">Sell $KRK</h2>
+    <p>$KRK can be sold anytime on <a href="https://uniswap.org">Uniswap</a></p>
   </div>
 </template>
 
diff --git a/landing/src/views/docs/LiquidityManagement.vue b/landing/src/views/docs/LiquidityManagement.vue
index 8fb40fa..7a4efac 100644
--- a/landing/src/views/docs/LiquidityManagement.vue
+++ b/landing/src/views/docs/LiquidityManagement.vue
@@ -64,21 +64,28 @@
       A critical aspect of the Floor position is its use of Volume Weighted Average Price (VWAP) to determine its pricing strategy. VWAP
       represents the average sale price of $KRK tokens weighted by trading volume, providing a kind of approximate and compressed memory
       over historic sales of tokens from its liquidity. The LM calculates the VWAP using cumulative trade data, ensuring that on average
-      tokens are bought back for cheaper than they were sold for. By anchoring the protocol’s liquidity to a VWAP-adjusted price, the system
+      tokens are bought back for cheaper than they were sold for. By anchoring the protocol's liquidity to a VWAP-adjusted price, the system
       retains a sober approach to Floor positioning while allowing for market-responsive adjustments of Anchor and Discovery.
     </p>
 
+    <p>
+      The VWAP also serves as a <strong>dormant whale defense</strong>. Because the VWAP only records prices during buying activity (ETH
+      inflow), an attacker who sells heavily cannot dilute the VWAP downward. The Floor uses the VWAP as a mirror &mdash; during sell
+      pressure, the growing distance between the current price and the VWAP automatically pushes the Floor further away, making it
+      progressively harder to drain. This "price memory" mechanism provides passive protection against coordinated sell attacks without
+      requiring any external intervention.
+    </p>
+
     <h2>Anchor Position</h2>
 
     <p>
       The Anchor position offers less liquidity depth than the Floor but spans a broader price range. It is always positioned at the current
-      market price, ensuring its relevance to active trading. The size of the Anchor position dynamically adjusts based on the "sentiment"
-      input, a value generated by an on-chain AI agent analyzing staking signals and trading data. Sentiment determines the allocation of 5%
-      to 25% of the total $ETH supply to the Anchor, influencing its liquidity depth and responsiveness. This adaptive sizing strategy puts
-      more capital at risk during market uptrends while adopting a defensive posture when sentiment turns negative. The exact adjustment
-      strategy depends on the training embedded in the on-chain AI agent, which targets developing the token price and maximizing trading
-      fees for the protocol. For more on staking signals, visit the "For Owners" chapter, and for details about the AI agent, see the
-      "AI-Agent" chapter.
+      market price, ensuring its relevance to active trading. The size and width of the Anchor adapt based on the market regime determined by
+      the Optimizer, which reads Harberger staking sentiment to classify conditions as <strong>bear</strong> or <strong>bull</strong>. In
+      bear mode, the Anchor is conservative (30% of ETH, wide range) to minimize exposure. In bull mode, triggered only when staking
+      signals indicate genuine community euphoria, the Anchor becomes aggressive (up to 100% of ETH, narrow range) to maximize fee capture.
+      This adaptive strategy puts more capital at risk during confirmed uptrends while maintaining a defensive posture by default. For more
+      on staking signals, visit the "Staking" chapter, and for details about the Optimizer, see the "AI-Agent" chapter.
     </p>
 
     <h2>Discovery Position</h2>
diff --git a/landing/src/views/docs/StakingDocs.vue b/landing/src/views/docs/StakingDocs.vue
index 1eda1a2..3886b98 100644
--- a/landing/src/views/docs/StakingDocs.vue
+++ b/landing/src/views/docs/StakingDocs.vue
@@ -66,7 +66,7 @@
   <div class="concept-block">
     <h2>2. Harberger Tax Mechanism</h2>
     <p>
-      To keep things fair and transparent, stakers need to pay a sel-assessed tax on their position. Inspired by the
+      To keep things fair and transparent, stakers need to pay a self-assessed tax on their position. Inspired by the
       <a href="https://en.wikipedia.org/wiki/Harberger_tax" target="_blank">Harberger tax concept</a> but adapted for crypto:
     </p>
 
@@ -125,7 +125,7 @@
     </ul>
 
     <p class="warning">
-      Key Insight: Losing a postion due to a buyout means lossing the benefit of <em>future</em> earnings from that stake, not existing
+      Key Insight: Losing a position due to a buyout means losing the benefit of <em>future</em> earnings from that stake, not existing
       tokens or profit.
     </p>
   </div>
diff --git a/onchain/src/Kraiken.sol b/onchain/src/Kraiken.sol
index 0b494ad..9455586 100644
--- a/onchain/src/Kraiken.sol
+++ b/onchain/src/Kraiken.sol
@@ -24,11 +24,14 @@ contract Kraiken is ERC20, ERC20Permit {
      *
      * Version History:
      * - v1: Initial deployment with 30-tier TAX_RATES
+     * - v2: OptimizerV3, VWAP mirror floor, directional VWAP recording
      */
-    uint256 public constant VERSION = 1;
+    uint256 public constant VERSION = 2;
 
     // Minimum fraction of the total supply required for staking to prevent fragmentation of staking positions
     uint256 private constant MIN_STAKE_FRACTION = 3000;
+    // Address authorized to call one-time setters (prevents frontrunning)
+    address private immutable deployer;
     // Address of the liquidity manager
     address private liquidityManager;
     // Address of the staking pool
@@ -52,7 +55,9 @@ contract Kraiken is ERC20, ERC20Permit {
      * @param name_ The name of the token
      * @param symbol_ The symbol of the token
      */
-    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) ERC20Permit(name_) { }
+    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) ERC20Permit(name_) {
+        deployer = msg.sender;
+    }
 
     /**
      * @notice Sets the address for the liquidityManager. Used once post-deployment to initialize the contract.
@@ -61,6 +66,7 @@ contract Kraiken is ERC20, ERC20Permit {
      * @param liquidityManager_ The address of the liquidity manager.
      */
     function setLiquidityManager(address liquidityManager_) external {
+        require(msg.sender == deployer, "only deployer");
         if (address(0) == liquidityManager_) revert ZeroAddressInSetter();
         if (liquidityManager != address(0)) revert AddressAlreadySet();
         liquidityManager = liquidityManager_;
@@ -73,6 +79,7 @@ contract Kraiken is ERC20, ERC20Permit {
      * @param stakingPool_ The address of the staking pool.
      */
     function setStakingPool(address stakingPool_) external {
+        require(msg.sender == deployer, "only deployer");
         if (address(0) == stakingPool_) revert ZeroAddressInSetter();
         if (stakingPool != address(0)) revert AddressAlreadySet();
         stakingPool = stakingPool_;
diff --git a/onchain/src/LiquidityManager.sol b/onchain/src/LiquidityManager.sol
index 32b6a13..047450a 100644
--- a/onchain/src/LiquidityManager.sol
+++ b/onchain/src/LiquidityManager.sol
@@ -3,15 +3,15 @@ pragma solidity ^0.8.19;
 
 import { Kraiken } from "./Kraiken.sol";
 import { Optimizer } from "./Optimizer.sol";
-
-import "./abstracts/PriceOracle.sol";
-import "./abstracts/ThreePositionStrategy.sol";
-import "./interfaces/IWETH9.sol";
-import "@aperture/uni-v3-lib/CallbackValidation.sol";
-import "@aperture/uni-v3-lib/PoolAddress.sol";
-import "@openzeppelin/token/ERC20/IERC20.sol";
-import "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol";
-import "@uniswap-v3-periphery/libraries/PositionKey.sol";
+import { PriceOracle } from "./abstracts/PriceOracle.sol";
+import { ThreePositionStrategy } from "./abstracts/ThreePositionStrategy.sol";
+import { IWETH9 } from "./interfaces/IWETH9.sol";
+import { CallbackValidation } from "@aperture/uni-v3-lib/CallbackValidation.sol";
+import { PoolAddress, PoolKey } from "@aperture/uni-v3-lib/PoolAddress.sol";
+import { IERC20 } from "@openzeppelin/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/token/ERC20/utils/SafeERC20.sol";
+import { IUniswapV3Pool } from "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol";
+import { PositionKey } from "@uniswap-v3-periphery/libraries/PositionKey.sol";
 
 /**
  * @title LiquidityManager
@@ -29,6 +29,8 @@ import "@uniswap-v3-periphery/libraries/PositionKey.sol";
  * - Prevents oracle manipulation attacks
  */
 contract LiquidityManager is ThreePositionStrategy, PriceOracle {
+    using SafeERC20 for IERC20;
+
     /// @notice Uniswap V3 fee tier (1%) - 10,000 basis points
     uint24 internal constant FEE = uint24(10_000);
 
@@ -42,9 +44,21 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
     PoolKey private poolKey;
 
     /// @notice Access control and fee management
+    address private immutable deployer;
     address public recenterAccess;
     address public feeDestination;
 
+    /// @notice Last recenter tick — used to determine net trade direction between recenters
+    int24 public lastRecenterTick;
+
+    /// @notice Last recenter timestamp — rate limits open (permissionless) recenters
+    uint256 public lastRecenterTime;
+    /// @notice Minimum seconds between open recenters (when recenterAccess is unset)
+    uint256 internal constant MIN_RECENTER_INTERVAL = 60;
+
+    /// @notice Emitted on each successful recenter for monitoring and indexing
+    event Recentered(int24 indexed currentTick, bool indexed isUp);
+
     /// @notice Custom errors
     error ZeroAddressInSetter();
     error AddressAlreadySet();
@@ -61,6 +75,7 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
     /// @param _kraiken The address of the Kraiken token contract
     /// @param _optimizer The address of the optimizer contract
     constructor(address _factory, address _WETH9, address _kraiken, address _optimizer) {
+        deployer = msg.sender;
         factory = _factory;
         weth = IWETH9(_WETH9);
         poolKey = PoolAddress.getPoolKey(_WETH9, _kraiken, FEE);
@@ -90,13 +105,14 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
         }
 
         // Transfer tokens to pool
-        if (amount0Owed > 0) IERC20(poolKey.token0).transfer(msg.sender, amount0Owed);
-        if (amount1Owed > 0) IERC20(poolKey.token1).transfer(msg.sender, amount1Owed);
+        if (amount0Owed > 0) IERC20(poolKey.token0).safeTransfer(msg.sender, amount0Owed);
+        if (amount1Owed > 0) IERC20(poolKey.token1).safeTransfer(msg.sender, amount1Owed);
     }
 
-    /// @notice Sets the fee destination address (can only be called once)
+    /// @notice Sets the fee destination address (can only be called once, deployer only)
     /// @param feeDestination_ The address that will receive trading fees
     function setFeeDestination(address feeDestination_) external {
+        require(msg.sender == deployer, "only deployer");
         if (address(0) == feeDestination_) revert ZeroAddressInSetter();
         if (feeDestination != address(0)) revert AddressAlreadySet();
         feeDestination = feeDestination_;
@@ -122,8 +138,10 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
         if (recenterAccess != address(0)) {
             require(msg.sender == recenterAccess, "access denied");
         } else {
+            require(block.timestamp >= lastRecenterTime + MIN_RECENTER_INTERVAL, "recenter cooldown");
             require(_isPriceStable(currentTick), "price deviated from oracle");
         }
+        lastRecenterTime = block.timestamp;
 
         // Check if price movement is sufficient for recentering
         isUp = false;
@@ -138,7 +156,22 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
         }
 
         // Remove all existing positions and collect fees
-        _scrapePositions();
+        // Pass tick direction to determine if VWAP should record (ETH inflow only)
+        bool shouldRecordVWAP;
+        if (cumulativeVolume == 0) {
+            // No VWAP data yet — always bootstrap to prevent vwapX96=0 fallback
+            shouldRecordVWAP = true;
+        } else if (lastRecenterTick != 0) {
+            // token0isWeth: tick DOWN = price up in KRK terms = buys = ETH inflow
+            // !token0isWeth: tick UP = price up in KRK terms = buys = ETH inflow
+            shouldRecordVWAP = token0isWeth ? (currentTick < lastRecenterTick) : (currentTick > lastRecenterTick);
+        } else {
+            // First recenter — no reference point, record conservatively
+            shouldRecordVWAP = true;
+        }
+        lastRecenterTick = currentTick;
+
+        _scrapePositions(shouldRecordVWAP);
 
         // Update total supply tracking if price moved up
         if (isUp) {
@@ -157,20 +190,23 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
 
             _setPositions(currentTick, params);
         } catch {
-            // Fallback to default parameters if optimizer fails
+            // Fallback to safe bear-mode defaults if optimizer fails
             PositionParams memory defaultParams = PositionParams({
-                capitalInefficiency: 5 * 10 ** 17, // 50%
-                anchorShare: 5 * 10 ** 17, // 50%
-                anchorWidth: 50, // 50%
-                discoveryDepth: 5 * 10 ** 17 // 50%
+                capitalInefficiency: 0, // CI=0 proven safest
+                anchorShare: 3e17, // 30% — defensive floor allocation
+                anchorWidth: 100, // Max width — avoids AW 30-90 kill zone
+                discoveryDepth: 3e17 // 0.3e18
              });
 
             _setPositions(currentTick, defaultParams);
         }
+
+        emit Recentered(currentTick, isUp);
     }
 
     /// @notice Removes all positions and collects fees
-    function _scrapePositions() internal {
+    /// @param recordVWAP Whether to record VWAP (only when net ETH inflow since last recenter)
+    function _scrapePositions(bool recordVWAP) internal {
         uint256 fee0 = 0;
         uint256 fee1 = 0;
         uint256 currentPrice;
@@ -197,21 +233,23 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
         }
 
         // Transfer fees and record volume for VWAP
+        // Only record VWAP when net ETH inflow (KRK sold out) — prevents sell-back
+        // activity from diluting the price memory of original KRK distribution
         if (fee0 > 0) {
             if (token0isWeth) {
-                IERC20(address(weth)).transfer(feeDestination, fee0);
-                _recordVolumeAndPrice(currentPrice, fee0);
+                IERC20(address(weth)).safeTransfer(feeDestination, fee0);
+                if (recordVWAP) _recordVolumeAndPrice(currentPrice, fee0);
             } else {
-                IERC20(address(kraiken)).transfer(feeDestination, fee0);
+                IERC20(address(kraiken)).safeTransfer(feeDestination, fee0);
             }
         }
 
         if (fee1 > 0) {
             if (token0isWeth) {
-                IERC20(address(kraiken)).transfer(feeDestination, fee1);
+                IERC20(address(kraiken)).safeTransfer(feeDestination, fee1);
             } else {
-                IERC20(address(weth)).transfer(feeDestination, fee1);
-                _recordVolumeAndPrice(currentPrice, fee1);
+                IERC20(address(weth)).safeTransfer(feeDestination, fee1);
+                if (recordVWAP) _recordVolumeAndPrice(currentPrice, fee1);
             }
         }
     }
@@ -255,7 +293,17 @@ contract LiquidityManager is ThreePositionStrategy, PriceOracle {
     }
 
     /// @notice Implementation of abstract function from ThreePositionStrategy
+    /// @dev Subtracts KRK at feeDestination (protocol revenue) and stakingPool (locked in staking)
+    ///      since neither can be sold into the floor — only trader-held KRK matters for scarcity
     function _getOutstandingSupply() internal view override returns (uint256) {
-        return kraiken.outstandingSupply();
+        uint256 supply = kraiken.outstandingSupply();
+        if (feeDestination != address(0)) {
+            supply -= kraiken.balanceOf(feeDestination);
+        }
+        (, address stakingPoolAddr) = kraiken.peripheryContracts();
+        if (stakingPoolAddr != address(0)) {
+            supply -= kraiken.balanceOf(stakingPoolAddr);
+        }
+        return supply;
     }
 }
diff --git a/onchain/src/OptimizerV2.sol b/onchain/src/OptimizerV2.sol
new file mode 100644
index 0000000..99e7ce2
--- /dev/null
+++ b/onchain/src/OptimizerV2.sol
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import { Kraiken } from "./Kraiken.sol";
+import { Stake } from "./Stake.sol";
+import { Math } from "@openzeppelin/utils/math/Math.sol";
+
+import { Initializable } from "@openzeppelin/proxy/utils/Initializable.sol";
+import { UUPSUpgradeable } from "@openzeppelin/proxy/utils/UUPSUpgradeable.sol";
+
+/**
+ * @title OptimizerV2
+ * @notice Sentiment-driven liquidity parameter optimizer based on empirical fuzzing results.
+ * @dev Replaces the original Optimizer with a mapping informed by adversarial analysis:
+ *
+ * Key findings from parameter sweep + Gaussian competition model:
+ *
+ * 1. capitalInefficiency has ZERO effect on fee revenue. It only affects floor placement.
+ *    Always set to 0 for maximum safety (adjusted VWAP = 0.7× → furthest floor).
+ *
+ * 2. anchorShare and anchorWidth are the ONLY fee levers:
+ *    - Bull: AS=100%, AW=20 → deep narrow anchor → maximizes KRK fees (which appreciate)
+ *    - Bear: AS=10%, AW=100 → thin wide anchor → maximizes WETH fees + safe floor distance
+ *
+ * 3. The two regimes naturally align safety with fee optimization:
+ *    - Bearish config is also the safest against drain attacks (AW=100 → 7000 tick clamp)
+ *    - Bullish config maximizes revenue when floor safety is least needed
+ *
+ * Staking sentiment drives the interpolation:
+ * - High staking % + low tax rate → bullish (sentiment=0) → aggressive fee capture
+ * - Low staking % + high tax rate → bearish (sentiment=1e18) → defensive positioning
+ */
+contract OptimizerV2 is Initializable, UUPSUpgradeable {
+    Kraiken private kraiken;
+    Stake private stake;
+
+    /// @dev Reverts if the caller is not the admin.
+    error UnauthorizedAccount(address account);
+
+    function initialize(address _kraiken, address _stake) public initializer {
+        _changeAdmin(msg.sender);
+        kraiken = Kraiken(_kraiken);
+        stake = Stake(_stake);
+    }
+
+    modifier onlyAdmin() {
+        _checkAdmin();
+        _;
+    }
+
+    function _checkAdmin() internal view virtual {
+        if (_getAdmin() != msg.sender) {
+            revert UnauthorizedAccount(msg.sender);
+        }
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyAdmin { }
+
+    /**
+     * @notice Calculates sentiment from staking metrics.
+     * @dev Reuses the V1 sentiment formula for continuity.
+     *      sentiment = 0 → bullish, sentiment = 1e18 → bearish.
+     */
+    function calculateSentiment(uint256 averageTaxRate, uint256 percentageStaked) public pure returns (uint256 sentimentValue) {
+        require(percentageStaked <= 1e18, "Invalid percentage staked");
+
+        uint256 deltaS = 1e18 - percentageStaked;
+
+        if (percentageStaked > 92e16) {
+            uint256 penalty = (deltaS * deltaS * deltaS * averageTaxRate) / (20 * 1e48);
+            sentimentValue = penalty / 2;
+        } else {
+            uint256 scaledStake = (percentageStaked * 1e18) / (92e16);
+            uint256 baseSentiment = scaledStake >= 1e18 ? 0 : 1e18 - scaledStake;
+            if (averageTaxRate <= 1e16) {
+                sentimentValue = baseSentiment;
+            } else if (averageTaxRate <= 5e16) {
+                uint256 ratePenalty = ((averageTaxRate - 1e16) * baseSentiment) / (4e16);
+                sentimentValue = baseSentiment > ratePenalty ? baseSentiment - ratePenalty : 0;
+            } else {
+                sentimentValue = 1e18;
+            }
+        }
+    }
+
+    function getSentiment() external view returns (uint256 sentiment) {
+        uint256 percentageStaked = stake.getPercentageStaked();
+        uint256 averageTaxRate = stake.getAverageTaxRate();
+        sentiment = calculateSentiment(averageTaxRate, percentageStaked);
+    }
+
+    /**
+     * @notice Returns liquidity parameters driven by staking sentiment.
+     *
+     * @return capitalInefficiency Always 0 — maximizes floor safety with no fee cost.
+     * @return anchorShare sqrt-scaled: bull(0)=100% → bear(1e18)=10%.
+     * @return anchorWidth sqrt-scaled: bull(0)=20 → bear(1e18)=100.
+     * @return discoveryDepth Interpolated with sentiment (unchanged from V1).
+     *
+     * @dev Uses square-root response curve for ASYMMETRIC transitions:
+     *      - Slow ramp to bull: requires sustained high staking to reach aggressive params
+     *      - Fast snap to bear: small drops in staking cause large safety jumps
+     *      Makes staking manipulation expensive: attacker must maintain >90% staking.
+     */
+    function getLiquidityParams() external view returns (uint256 capitalInefficiency, uint256 anchorShare, uint24 anchorWidth, uint256 discoveryDepth) {
+        uint256 percentageStaked = stake.getPercentageStaked();
+        uint256 averageTaxRate = stake.getAverageTaxRate();
+        uint256 sentiment = calculateSentiment(averageTaxRate, percentageStaked);
+
+        if (sentiment > 1e18) sentiment = 1e18;
+
+        // CI = 0 always. No fee impact, maximum floor safety.
+        capitalInefficiency = 0;
+
+        // sqrt(sentiment) for aggressive bear transition:
+        // sentiment=2.2% (staking=90%) → sqrtS=14.8% → already shifting defensive
+        // sentiment=13%  (staking=80%) → sqrtS=36%  → well into defensive
+        // sentiment=100% (staking=0%)  → sqrtS=100% → full bear
+        uint256 sqrtS = Math.sqrt(sentiment * 1e18);
+        // sqrtS is now in range [0, 1e18]. Scale to match sentiment range.
+
+        // AS: 100% (bull) → 10% (bear), sqrt-scaled
+        anchorShare = 1e18 - (sqrtS * 90 / 100);
+
+        // AW: 20 (bull) → 100 (bear), sqrt-scaled
+        anchorWidth = uint24(20 + (sqrtS * 80 / 1e18));
+
+        // DD: keep sentiment-driven (V1 behavior)
+        discoveryDepth = sentiment;
+    }
+}
diff --git a/onchain/src/OptimizerV3.sol b/onchain/src/OptimizerV3.sol
new file mode 100644
index 0000000..7f58b9f
--- /dev/null
+++ b/onchain/src/OptimizerV3.sol
@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import { Kraiken } from "./Kraiken.sol";
+import { Stake } from "./Stake.sol";
+
+import { Initializable } from "@openzeppelin/proxy/utils/Initializable.sol";
+import { UUPSUpgradeable } from "@openzeppelin/proxy/utils/UUPSUpgradeable.sol";
+
+/**
+ * @title OptimizerV3
+ * @notice Direct 2D (staking%, avgTax) → binary bear/bull liquidity optimizer.
+ * @dev Replaces the three-zone score-based model with a direct mapping:
+ *
+ *      staked ≤ 91% → BEAR always (no euphoria signal)
+ *      staked > 91% → BULL if deltaS³ × effIdx / 20 < 50, else BEAR
+ *
+ *      where deltaS = 100 - stakedPct, effIdx = min(29, taxIdx + (taxIdx >= 14 ? 1 : 0))
+ *
+ *      Bear: AS=30%, AW=100, CI=0, DD=0.3e18
+ *      Bull: AS=100%, AW=20, CI=0, DD=1e18
+ *
+ *      The binary step avoids the AW 30-90 kill zone where intermediate params are exploitable.
+ *      CI = 0 always (proven to have zero effect on fee revenue).
+ *
+ *      Bull requires >91% staked with low enough tax. Any decline → instant snap to bear.
+ */
+contract OptimizerV3 is Initializable, UUPSUpgradeable {
+    Kraiken private kraiken;
+    Stake private stake;
+
+    /// @dev Reserved storage gap for future upgrades (50 slots total: 2 used + 48 reserved)
+    uint256[48] private __gap;
+
+    /// @dev Reverts if the caller is not the admin.
+    error UnauthorizedAccount(address account);
+
+    /// @notice Initializes the proxy with Kraiken and Stake contract references.
+    /// @param _kraiken The Kraiken token contract address
+    /// @param _stake The Stake contract address
+    function initialize(address _kraiken, address _stake) public initializer {
+        _changeAdmin(msg.sender);
+        kraiken = Kraiken(_kraiken);
+        stake = Stake(_stake);
+    }
+
+    modifier onlyAdmin() {
+        _checkAdmin();
+        _;
+    }
+
+    function _checkAdmin() internal view virtual {
+        if (_getAdmin() != msg.sender) {
+            revert UnauthorizedAccount(msg.sender);
+        }
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyAdmin { }
+
+    /**
+     * @notice Maps a normalized average tax rate (0-1e18) to an effective tax rate index.
+     * @dev The Stake contract normalizes: averageTaxRate = rawRate * 1e18 / MAX_TAX_RATE.
+     *      We compare against pre-computed normalized midpoints between adjacent TAX_RATES
+     *      to find the closest index, avoiding double-truncation from denormalization.
+     *
+     *      The effective index has a +1 shift at position ≥14 to account for the
+     *      non-uniform spacing in the TAX_RATES array (130% → 180% is a 38% jump),
+     *      capped at 29.
+     */
+    function _taxRateToEffectiveIndex(uint256 averageTaxRate) internal pure returns (uint256) {
+        // Pre-computed normalized midpoints between adjacent TAX_RATES:
+        // midpoint_norm = ((TAX_RATES[i] + TAX_RATES[i+1]) / 2) * 1e18 / 9700
+        // Using these directly avoids integer truncation from denormalization.
+        uint256 idx;
+        if (averageTaxRate <= 206_185_567_010_309) idx = 0; // midpoint(1,3)
+
+        else if (averageTaxRate <= 412_371_134_020_618) idx = 1; // midpoint(3,5)
+
+        else if (averageTaxRate <= 618_556_701_030_927) idx = 2; // midpoint(5,8)
+
+        else if (averageTaxRate <= 1_030_927_835_051_546) idx = 3; // midpoint(8,12)
+
+        else if (averageTaxRate <= 1_546_391_752_577_319) idx = 4; // midpoint(12,18)
+
+        else if (averageTaxRate <= 2_164_948_453_608_247) idx = 5; // midpoint(18,24)
+
+        else if (averageTaxRate <= 2_783_505_154_639_175) idx = 6; // midpoint(24,30)
+
+        else if (averageTaxRate <= 3_608_247_422_680_412) idx = 7; // midpoint(30,40)
+
+        else if (averageTaxRate <= 4_639_175_257_731_958) idx = 8; // midpoint(40,50)
+
+        else if (averageTaxRate <= 5_670_103_092_783_505) idx = 9; // midpoint(50,60)
+
+        else if (averageTaxRate <= 7_216_494_845_360_824) idx = 10; // midpoint(60,80)
+
+        else if (averageTaxRate <= 9_278_350_515_463_917) idx = 11; // midpoint(80,100)
+
+        else if (averageTaxRate <= 11_855_670_103_092_783) idx = 12; // midpoint(100,130)
+
+        else if (averageTaxRate <= 15_979_381_443_298_969) idx = 13; // midpoint(130,180)
+
+        else if (averageTaxRate <= 22_164_948_453_608_247) idx = 14; // midpoint(180,250)
+
+        else if (averageTaxRate <= 29_381_443_298_969_072) idx = 15; // midpoint(250,320)
+
+        else if (averageTaxRate <= 38_144_329_896_907_216) idx = 16; // midpoint(320,420)
+
+        else if (averageTaxRate <= 49_484_536_082_474_226) idx = 17; // midpoint(420,540)
+
+        else if (averageTaxRate <= 63_917_525_773_195_876) idx = 18; // midpoint(540,700)
+
+        else if (averageTaxRate <= 83_505_154_639_175_257) idx = 19; // midpoint(700,920)
+
+        else if (averageTaxRate <= 109_278_350_515_463_917) idx = 20; // midpoint(920,1200)
+
+        else if (averageTaxRate <= 144_329_896_907_216_494) idx = 21; // midpoint(1200,1600)
+
+        else if (averageTaxRate <= 185_567_010_309_278_350) idx = 22; // midpoint(1600,2000)
+
+        else if (averageTaxRate <= 237_113_402_061_855_670) idx = 23; // midpoint(2000,2600)
+
+        else if (averageTaxRate <= 309_278_350_515_463_917) idx = 24; // midpoint(2600,3400)
+
+        else if (averageTaxRate <= 402_061_855_670_103_092) idx = 25; // midpoint(3400,4400)
+
+        else if (averageTaxRate <= 520_618_556_701_030_927) idx = 26; // midpoint(4400,5700)
+
+        else if (averageTaxRate <= 680_412_371_134_020_618) idx = 27; // midpoint(5700,7500)
+
+        else if (averageTaxRate <= 886_597_938_144_329_896) idx = 28; // midpoint(7500,9700)
+
+        else idx = 29;
+
+        // Apply effective index shift: +1 at idx >= 14, capped at 29
+        if (idx >= 14) {
+            idx = idx + 1;
+            if (idx > 29) idx = 29;
+        }
+
+        return idx;
+    }
+
+    /**
+     * @notice Determines if the market is in bull configuration.
+     * @param percentageStaked Percentage of authorized stake in use (0 to 1e18).
+     * @param averageTaxRate Normalized average tax rate from Stake contract (0 to 1e18).
+     * @return bull True if bull config, false if bear.
+     *
+     * @dev Direct 2D mapping — no intermediate score:
+     *      staked ≤ 91% → always bear (no euphoria signal)
+     *      staked > 91% → bull if deltaS³ × effIdx / 20 < 50
+     *      where deltaS = 100 - stakedPct (integer percentage)
+     */
+    function isBullMarket(uint256 percentageStaked, uint256 averageTaxRate) public pure returns (bool bull) {
+        require(percentageStaked <= 1e18, "Invalid percentage staked");
+
+        uint256 stakedPct = percentageStaked * 100 / 1e18; // 0-100
+        if (stakedPct <= 91) return false;
+
+        uint256 deltaS = 100 - stakedPct; // 0-8
+        uint256 effIdx = _taxRateToEffectiveIndex(averageTaxRate);
+        uint256 penalty = deltaS * deltaS * deltaS * effIdx / 20;
+        return penalty < 50;
+    }
+
+    /**
+     * @notice Returns liquidity parameters driven by the direct 2D staking→config mapping.
+     *
+     * @return capitalInefficiency Always 0 — proven to have zero effect on fee revenue.
+     * @return anchorShare Bear=30% (0.3e18), Bull=100% (1e18).
+     * @return anchorWidth Bear=100, Bull=20.
+     * @return discoveryDepth Bear=0.3e18, Bull=1e18.
+     */
+    function getLiquidityParams() external view returns (uint256 capitalInefficiency, uint256 anchorShare, uint24 anchorWidth, uint256 discoveryDepth) {
+        uint256 percentageStaked = stake.getPercentageStaked();
+        uint256 averageTaxRate = stake.getAverageTaxRate();
+
+        capitalInefficiency = 0;
+
+        if (isBullMarket(percentageStaked, averageTaxRate)) {
+            anchorShare = 1e18; // 100%
+            anchorWidth = 20;
+            discoveryDepth = 1e18;
+        } else {
+            anchorShare = 3e17; // 30%
+            anchorWidth = 100;
+            discoveryDepth = 3e17; // 0.3e18
+        }
+    }
+}
diff --git a/onchain/src/VWAPTracker.sol b/onchain/src/VWAPTracker.sol
index cf0ea59..f2cc930 100644
--- a/onchain/src/VWAPTracker.sol
+++ b/onchain/src/VWAPTracker.sol
@@ -22,10 +22,9 @@ abstract contract VWAPTracker {
 
     /**
      * @notice Records volume and price data for VWAP calculation
-     * @param currentPriceX96 The current price in X96 format (actually price² from _priceAtTick)
+     * @param currentPriceX96 The current price in Q96 format (price * 2^96, from _priceAtTick)
      * @param fee The fee amount used to calculate volume
      * @dev Assumes fee represents 1% of volume, handles overflow by compressing historic data
-     * @dev IMPORTANT: currentPriceX96 is expected to be price² (squared price), not regular price
      */
     function _recordVolumeAndPrice(uint256 currentPriceX96, uint256 fee) internal {
         // assuming FEE is 1%
diff --git a/onchain/src/abstracts/PriceOracle.sol b/onchain/src/abstracts/PriceOracle.sol
index b73290d..c7a444a 100644
--- a/onchain/src/abstracts/PriceOracle.sol
+++ b/onchain/src/abstracts/PriceOracle.sol
@@ -34,10 +34,11 @@ abstract contract PriceOracle {
             averageTick = int24(tickCumulativeDiff / int56(int32(PRICE_STABILITY_INTERVAL)));
         } catch {
             // Fallback to longer timeframe if recent data unavailable
-            secondsAgo[0] = PRICE_STABILITY_INTERVAL * 200;
+            uint32 fallbackInterval = PRICE_STABILITY_INTERVAL * 200; // 60,000 seconds
+            secondsAgo[0] = fallbackInterval;
             (int56[] memory tickCumulatives,) = pool.observe(secondsAgo);
             int56 tickCumulativeDiff = tickCumulatives[1] - tickCumulatives[0];
-            averageTick = int24(tickCumulativeDiff / int56(int32(PRICE_STABILITY_INTERVAL)));
+            averageTick = int24(tickCumulativeDiff / int56(int32(fallbackInterval)));
         }
 
         isStable = (currentTick >= averageTick - MAX_TICK_DEVIATION && currentTick <= averageTick + MAX_TICK_DEVIATION);
diff --git a/onchain/src/abstracts/ThreePositionStrategy.sol b/onchain/src/abstracts/ThreePositionStrategy.sol
index eb3c38f..1f45ada 100644
--- a/onchain/src/abstracts/ThreePositionStrategy.sol
+++ b/onchain/src/abstracts/ThreePositionStrategy.sol
@@ -56,11 +56,14 @@ abstract contract ThreePositionStrategy is UniswapMath, VWAPTracker {
     /// @notice Storage for the three positions
     mapping(Stage => TokenPosition) public positions;
 
+    /// @notice Deprecated — was floor high-water mark. Kept for storage layout compatibility.
+    int24 public __deprecated_floorHighWaterMark;
+
     /// @notice Events for tracking ETH abundance/scarcity scenarios
     event EthScarcity(int24 currentTick, uint256 ethBalance, uint256 outstandingSupply, uint256 vwap, int24 vwapTick);
     event EthAbundance(int24 currentTick, uint256 ethBalance, uint256 outstandingSupply, uint256 vwap, int24 vwapTick);
-
     /// @notice Abstract functions that must be implemented by inheriting contracts
+
     function _getKraikenToken() internal view virtual returns (address);
     function _getWethToken() internal view virtual returns (address);
     function _isToken0Weth() internal view virtual returns (bool);
@@ -188,43 +191,10 @@ abstract contract ThreePositionStrategy is UniswapMath, VWAPTracker {
         outstandingSupply -= pulledKraiken;
         outstandingSupply -= (outstandingSupply >= discoveryAmount) ? discoveryAmount : outstandingSupply;
 
-        // Use VWAP for floor position (historical price memory for dormant whale protection)
-        uint256 vwapX96 = getAdjustedVWAP(params.capitalInefficiency);
-        uint256 ethBalance = _getEthBalance();
-        int24 vwapTick;
-
-        if (vwapX96 > 0) {
-            // vwapX96 is price² in X96 format, need to convert to regular price
-            // price = sqrt(price²) = sqrt(vwapX96) * 2^48 / 2^96 = sqrt(vwapX96) / 2^48
-            uint256 sqrtVwapX96 = Math.sqrt(vwapX96) << 48; // sqrt(price²) in X96 format
-            uint256 requiredEthForBuyback = outstandingSupply.mulDiv(sqrtVwapX96, (1 << 96));
-
-            if (floorEthBalance < requiredEthForBuyback) {
-                // ETH scarcity: not enough ETH to buy back at VWAP price
-                uint256 balancedCapital = (7 * outstandingSupply / 10) + (outstandingSupply * params.capitalInefficiency / 10 ** 18);
-                vwapTick = _tickAtPrice(token0isWeth, balancedCapital, floorEthBalance);
-                emit EthScarcity(currentTick, ethBalance, outstandingSupply, vwapX96, vwapTick);
-            } else {
-                // ETH abundance: sufficient ETH reserves
-                // vwapX96 is price² in X96 format, need to convert to regular price in X64 format
-                // price = sqrt(price²), then convert from X96 to X64 by >> 32
-                uint256 sqrtVwapX96Abundance = Math.sqrt(vwapX96) << 48; // sqrt(price²) in X96 format
-                vwapTick = _tickAtPriceRatio(int128(int256(sqrtVwapX96Abundance >> 32)));
-                vwapTick = token0isWeth ? -vwapTick : vwapTick;
-                emit EthAbundance(currentTick, ethBalance, outstandingSupply, vwapX96, vwapTick);
-            }
-        } else {
-            // No VWAP data available, use current tick
-            vwapTick = currentTick;
-        }
-
-        // Ensure floor doesn't overlap with anchor position
-        int24 anchorSpacing = TICK_SPACING + (34 * int24(params.anchorWidth) * TICK_SPACING / 100);
-        if (token0isWeth) {
-            vwapTick = (vwapTick < currentTick + anchorSpacing) ? currentTick + anchorSpacing : vwapTick;
-        } else {
-            vwapTick = (vwapTick > currentTick - anchorSpacing) ? currentTick - anchorSpacing : vwapTick;
-        }
+        // Floor placement: max of (scarcity, VWAP mirror, clamp) toward KRK-cheap side.
+        // VWAP mirror uses distance from VWAP as floor distance — during selling, price moves
+        // away from VWAP so floor retreats automatically. No sell-pressure detection needed.
+        int24 vwapTick = _computeFloorTick(currentTick, floorEthBalance, outstandingSupply, token0isWeth, params);
 
         // Normalize and create floor position
         vwapTick = _clampToTickSpacing(vwapTick, TICK_SPACING);
@@ -246,4 +216,54 @@ abstract contract ThreePositionStrategy is UniswapMath, VWAPTracker {
 
         _mintPosition(Stage.FLOOR, token0isWeth ? vwapTick : floorTick, token0isWeth ? floorTick : vwapTick, liquidity);
     }
+
+    /// @notice Computes floor tick from three signals: scarcity, VWAP mirror, and anti-overlap clamp.
+    /// @dev Takes the one furthest into KRK-cheap territory (highest tick when token0isWeth, lowest when not).
+    function _computeFloorTick(
+        int24 currentTick,
+        uint256 floorEthBalance,
+        uint256 outstandingSupply,
+        bool token0isWeth,
+        PositionParams memory params
+    )
+        internal
+        view
+        returns (int24 floorTarget)
+    {
+        // 1. Scarcity tick: at what price can our ETH buy back the adjusted supply?
+        uint256 balancedCapital = (7 * outstandingSupply / 10) + (outstandingSupply * params.capitalInefficiency / 10 ** 18);
+        int24 scarcityTick = currentTick;
+        if (outstandingSupply > 0 && floorEthBalance > 0) {
+            scarcityTick = _tickAtPrice(token0isWeth, balancedCapital, floorEthBalance);
+        }
+
+        // 2. Mirror tick: VWAP distance mirrored to KRK-cheap side
+        //    Uses adjusted VWAP (CI controls distance → CI is the risk lever).
+        int24 mirrorTick = currentTick;
+        {
+            uint256 vwapX96 = getAdjustedVWAP(params.capitalInefficiency);
+            if (vwapX96 > 0) {
+                int24 rawVwapTick = _tickAtPriceRatio(int128(int256(vwapX96 >> 32)));
+                rawVwapTick = token0isWeth ? -rawVwapTick : rawVwapTick;
+                int24 vwapDistance = currentTick - rawVwapTick;
+                if (vwapDistance < 0) vwapDistance = -vwapDistance;
+                mirrorTick = token0isWeth ? currentTick + vwapDistance : currentTick - vwapDistance;
+            }
+        }
+
+        // 3. Clamp tick: minimum distance (anti-overlap with anchor)
+        int24 anchorSpacing = TICK_SPACING + (34 * int24(params.anchorWidth) * TICK_SPACING / 100);
+        int24 clampTick = token0isWeth ? currentTick + anchorSpacing : currentTick - anchorSpacing;
+
+        // Take the one furthest into KRK-cheap territory
+        if (token0isWeth) {
+            floorTarget = scarcityTick;
+            if (mirrorTick > floorTarget) floorTarget = mirrorTick;
+            if (clampTick > floorTarget) floorTarget = clampTick;
+        } else {
+            floorTarget = scarcityTick;
+            if (mirrorTick < floorTarget) floorTarget = mirrorTick;
+            if (clampTick < floorTarget) floorTarget = clampTick;
+        }
+    }
 }
diff --git a/onchain/src/libraries/UniswapMath.sol b/onchain/src/libraries/UniswapMath.sol
index 26f1089..a3282bf 100644
--- a/onchain/src/libraries/UniswapMath.sol
+++ b/onchain/src/libraries/UniswapMath.sol
@@ -42,12 +42,11 @@ abstract contract UniswapMath {
         tick_ = TickMath.getTickAtSqrtRatio(sqrtPriceX96);
     }
 
-    /// @notice Calculates the price ratio from a given Uniswap V3 tick as KRAIKEN/ETH
-    /// @dev IMPORTANT: Returns price² (squared price) in X96 format, NOT regular price
-    ///      This is intentional for capital requirement calculations
-    ///      To get regular price: sqrt(priceRatioX96) * 2^48
+    /// @notice Calculates the price ratio from a given Uniswap V3 tick
+    /// @dev Returns price (token1/token0) in Q96 format: price * 2^96
+    ///      Computed as sqrtRatioX96² / 2^96 = (sqrt(price) * 2^96)² / 2^96 = price * 2^96
     /// @param tick The tick for which to calculate the price ratio
-    /// @return priceRatioX96 The price² (squared price) corresponding to the given tick
+    /// @return priceRatioX96 The price ratio in Q96 format
     function _priceAtTick(int24 tick) internal pure returns (uint256 priceRatioX96) {
         uint256 sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
         priceRatioX96 = sqrtRatioX96.mulDiv(sqrtRatioX96, (1 << 96));
diff --git a/onchain/test/EthScarcityAbundance.t.sol b/onchain/test/EthScarcityAbundance.t.sol
new file mode 100644
index 0000000..948793d
--- /dev/null
+++ b/onchain/test/EthScarcityAbundance.t.sol
@@ -0,0 +1,480 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import { SwapExecutor } from "../analysis/helpers/SwapExecutor.sol";
+import { Kraiken } from "../src/Kraiken.sol";
+import { LiquidityManager } from "../src/LiquidityManager.sol";
+import { ThreePositionStrategy } from "../src/abstracts/ThreePositionStrategy.sol";
+import { UniswapHelpers } from "../src/helpers/UniswapHelpers.sol";
+import { IWETH9 } from "../src/interfaces/IWETH9.sol";
+import { TestEnvironment } from "./helpers/TestBase.sol";
+import { ConfigurableOptimizer } from "./mocks/ConfigurableOptimizer.sol";
+import { IUniswapV3Factory } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
+import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
+import "forge-std/Test.sol";
+import "forge-std/console2.sol";
+
+/// @title EthScarcityAbundance
+/// @notice Tests investigating when EthScarcity vs EthAbundance fires,
+///         and the floor ratchet's effect during each condition.
+contract EthScarcityAbundance is Test {
+    TestEnvironment testEnv;
+    IUniswapV3Factory factory;
+    IUniswapV3Pool pool;
+    IWETH9 weth;
+    Kraiken kraiken;
+    LiquidityManager lm;
+    SwapExecutor swapExecutor;
+    ConfigurableOptimizer optimizer;
+    bool token0isWeth;
+
+    address trader = makeAddr("trader");
+    address fees = makeAddr("fees");
+
+    bytes32 constant SCARCITY_SIG = keccak256("EthScarcity(int24,uint256,uint256,uint256,int24)");
+    bytes32 constant ABUNDANCE_SIG = keccak256("EthAbundance(int24,uint256,uint256,uint256,int24)");
+
+    function setUp() public {
+        testEnv = new TestEnvironment(fees);
+        factory = UniswapHelpers.deployUniswapFactory();
+
+        // Default params: CI=50%, AS=50%, AW=50, DD=50%
+        optimizer = new ConfigurableOptimizer(5e17, 5e17, 50, 5e17);
+
+        (factory, pool, weth, kraiken,, lm,, token0isWeth) = testEnv.setupEnvironmentWithExistingFactory(factory, true, fees, address(optimizer));
+
+        swapExecutor = new SwapExecutor(pool, weth, kraiken, token0isWeth, lm, true);
+
+        // Fund LM generously
+        vm.deal(address(lm), 200 ether);
+        vm.prank(address(lm));
+        weth.deposit{ value: 100 ether }();
+
+        // Initial recenter
+        vm.prank(fees);
+        lm.recenter();
+
+        // Fund trader
+        vm.deal(trader, 300 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 300 ether }();
+    }
+
+    // ================================================================
+    // Q1: WHEN DOES EthScarcity/EthAbundance FIRE?
+    // ================================================================
+
+    /// @notice After a small buy and sell-back, EthAbundance fires on recenter.
+    /// This proves EthScarcity is NOT permanent.
+    function test_floor_placed_after_sellback() public {
+        console2.log("=== Floor placement after sell-back ===");
+
+        // Small buy to create some VWAP history
+        _executeBuy(5 ether);
+        _recenterAndLog("Post-buy");
+
+        // Sell ALL KRK back
+        _executeSell(kraiken.balanceOf(trader));
+
+        // Recenter after sell-back — should not revert
+        _recenterAndLog("Post-sellback");
+
+        // Floor position should exist (check via positions mapping)
+        (uint128 floorLiq,,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        assertTrue(floorLiq > 0, "Floor should be placed after sell-back");
+    }
+
+    /// @notice During sustained buy pressure, floor should be placed progressively
+    function test_floor_during_buy_pressure() public {
+        console2.log("=== Floor during buy pressure ===");
+
+        for (uint256 i = 0; i < 5; i++) {
+            _executeBuy(15 ether);
+            _recenterAndLog("Buy");
+        }
+
+        // Floor should have been placed on each recenter
+        (uint128 floorLiq,,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        assertTrue(floorLiq > 0, "Floor should be placed during buy pressure");
+    }
+
+    /// @notice After heavy buying, floor persists through sells via VWAP mirror.
+    function test_floor_retreats_through_bull_bear_cycle() public {
+        console2.log("=== Floor through bull-bear cycle ===");
+
+        // Bull phase: 5 buys of 15 ETH = 75 ETH total
+        for (uint256 i = 0; i < 5; i++) {
+            _executeBuy(15 ether);
+        }
+        _recenterAndLog("End of bull");
+
+        // Bear phase: sell everything in chunks with recenters
+        uint256 totalKrk = kraiken.balanceOf(trader);
+        uint256 remaining = totalKrk;
+        uint256 attempts;
+        while (remaining > 0 && attempts < 10) {
+            uint256 sellChunk = remaining > totalKrk / 3 ? totalKrk / 3 : remaining;
+            if (sellChunk == 0) break;
+            _executeSell(sellChunk);
+            remaining = kraiken.balanceOf(trader);
+            _recenterAndLog("Sell chunk");
+            attempts++;
+        }
+
+        // Floor should still exist after selling
+        (uint128 floorLiq,,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        assertTrue(floorLiq > 0, "Floor should persist through bear phase");
+    }
+
+    // ================================================================
+    // Q1 continued: IS THE FLOOR PERMANENTLY STUCK?
+    // ================================================================
+
+    /// @notice With conditional ratchet: floor tracks currentTick during abundance
+    /// but is locked during scarcity. Demonstrates the ratchet is now market-responsive.
+    function test_floor_tracks_price_during_abundance() public {
+        console2.log("=== Floor responds to market during EthAbundance ===");
+
+        // Record initial floor
+        (, int24 floorTickInit,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("Initial floor tickLower:", floorTickInit);
+
+        // Buy to push price, creating scarcity
+        _executeBuy(10 ether);
+        (bool scarcityA,,) = _recenterAndLog("After buy");
+        (, int24 floorAfterScarcity,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("Floor after scarcity recenter:", floorAfterScarcity);
+        console2.log("EthScarcity fired:", scarcityA);
+
+        // Sell back to trigger abundance
+        _executeSell(kraiken.balanceOf(trader));
+        (, bool abundanceA,) = _recenterAndLog("After sell-back");
+
+        (, int24 floorAfterAbundance,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("Floor after abundance recenter:", floorAfterAbundance);
+        console2.log("EthAbundance fired:", abundanceA);
+
+        // During abundance, floor is set by anti-overlap clamp: currentTick + anchorSpacing
+        // This tracks the current price rather than being permanently locked
+        (, int24 currentTick,,,,,) = pool.slot0();
+        // anchorSpacing for AW=50: 200 + (34 * 50 * 200 / 100) = 3600
+        int24 expectedBoundary = currentTick + 3600;
+        console2.log("Current tick:", currentTick);
+        console2.log("Expected floor boundary:", expectedBoundary);
+
+        // With conditional ratchet: during abundance, the ratchet is off,
+        // so floor can be at anti-overlap boundary (tracks current price)
+        // With permanent ratchet: floor would be max(prevFloor, boundary)
+
+        console2.log("FINDING: Floor responds to market during abundance");
+        console2.log("  Scarcity: floor locked (ratchet on)");
+        console2.log("  Abundance: floor at currentTick + anchorSpacing");
+    }
+
+    /// @notice During EthAbundance, the abundance vwapTick (from VWAP) is typically
+    /// far below the anti-overlap boundary, so the anti-overlap clamp sets the floor
+    /// to currentTick + anchorSpacing. With conditional ratchet, this tracks the
+    /// current price. With permanent ratchet, it would be max(prevFloor, boundary).
+    function test_abundance_floor_mechanism() public {
+        console2.log("=== How floor is set during abundance ===");
+
+        // Buy to create VWAP then sell back for abundance
+        _executeBuy(10 ether);
+        _recenterAndLog("After buy");
+        _executeSell(kraiken.balanceOf(trader));
+
+        // Recenter (expect abundance)
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.recordLogs();
+        vm.prank(fees);
+        lm.recenter();
+
+        (, int24 currentTick,,,,,) = pool.slot0();
+        (, int24 floorTickLower,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+
+        // anchorSpacing for AW=50: 200 + (34*50*200/100) = 3600
+        int24 antiOverlapBoundary = currentTick + 3600;
+
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        int24 abundanceVwapTick;
+        for (uint256 i = 0; i < logs.length; i++) {
+            if (logs[i].topics.length > 0 && logs[i].topics[0] == ABUNDANCE_SIG) {
+                (,,,, int24 vt) = abi.decode(logs[i].data, (int24, uint256, uint256, uint256, int24));
+                abundanceVwapTick = vt;
+            }
+        }
+
+        console2.log("Current tick:", currentTick);
+        console2.log("Anti-overlap boundary:", antiOverlapBoundary);
+        console2.log("Abundance vwapTick:", abundanceVwapTick);
+        console2.log("Floor tickLower:", floorTickLower);
+
+        // The abundance vwapTick is far below the anti-overlap boundary
+        // because VWAP price converts to a negative tick (token0isWeth sign flip)
+        assertTrue(abundanceVwapTick < antiOverlapBoundary, "VWAP tick below anti-overlap boundary");
+
+        // Floor ends up at anti-overlap boundary (clamped after tick spacing)
+        // With conditional ratchet: this tracks current price
+        // With permanent ratchet: this would be max(prevFloor, boundary)
+        console2.log("Floor set by: anti-overlap clamp (tracks current price)");
+    }
+
+    // ================================================================
+    // Q2: BULL/BEAR LIQUIDITY DISTRIBUTION & CONDITIONAL RATCHET
+    // ================================================================
+
+    /// @notice Demonstrates ideal bull vs bear parameter distribution
+    function test_bull_market_params() public {
+        console2.log("=== Bull vs Bear parameter comparison ===");
+
+        // Bull optimizer: high anchorShare, wide anchor, deep discovery
+        ConfigurableOptimizer bullOpt = new ConfigurableOptimizer(3e17, 8e17, 80, 8e17);
+
+        (,,,,, LiquidityManager bullLm,,) = testEnv.setupEnvironmentWithExistingFactory(factory, true, fees, address(bullOpt));
+
+        vm.deal(address(bullLm), 200 ether);
+        vm.prank(address(bullLm));
+        weth.deposit{ value: 100 ether }();
+        vm.prank(fees);
+        bullLm.recenter();
+
+        (uint128 floorLiq,,) = bullLm.positions(ThreePositionStrategy.Stage.FLOOR);
+        (uint128 anchorLiq, int24 aLow, int24 aHigh) = bullLm.positions(ThreePositionStrategy.Stage.ANCHOR);
+        (uint128 discLiq,,) = bullLm.positions(ThreePositionStrategy.Stage.DISCOVERY);
+
+        console2.log("Bull (AS=80% AW=80 DD=80% CI=30%):");
+        console2.log("  Floor liq:", uint256(floorLiq));
+        console2.log("  Anchor liq:", uint256(anchorLiq));
+        console2.log("  Anchor width:", uint256(int256(aHigh - aLow)));
+        console2.log("  Discovery liq:", uint256(discLiq));
+
+        // Bear optimizer: low anchorShare, moderate anchor, thin discovery
+        ConfigurableOptimizer bearOpt = new ConfigurableOptimizer(8e17, 1e17, 40, 2e17);
+
+        (,,,,, LiquidityManager bearLm,,) = testEnv.setupEnvironmentWithExistingFactory(factory, true, fees, address(bearOpt));
+
+        vm.deal(address(bearLm), 200 ether);
+        vm.prank(address(bearLm));
+        weth.deposit{ value: 100 ether }();
+        vm.prank(fees);
+        bearLm.recenter();
+
+        (uint128 bFloorLiq,,) = bearLm.positions(ThreePositionStrategy.Stage.FLOOR);
+        (uint128 bAnchorLiq, int24 bALow, int24 bAHigh) = bearLm.positions(ThreePositionStrategy.Stage.ANCHOR);
+        (uint128 bDiscLiq,,) = bearLm.positions(ThreePositionStrategy.Stage.DISCOVERY);
+
+        console2.log("Bear (AS=10% AW=40 DD=20% CI=80%):");
+        console2.log("  Floor liq:", uint256(bFloorLiq));
+        console2.log("  Anchor liq:", uint256(bAnchorLiq));
+        console2.log("  Anchor width:", uint256(int256(bAHigh - bALow)));
+        console2.log("  Discovery liq:", uint256(bDiscLiq));
+
+        assertGt(anchorLiq, bAnchorLiq, "Bull should have more anchor liquidity than bear");
+    }
+
+    /// @notice Tracks floor through scarcity -> abundance -> scarcity cycle.
+    /// Shows what a conditional ratchet WOULD allow.
+    function test_conditional_ratchet_concept() public {
+        console2.log("=== Conditional ratchet concept ===");
+
+        (, int24 floorTickInit,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("Initial floor:", floorTickInit);
+
+        // Phase 1: Buy pressure -> EthScarcity -> ratchet ACTIVE
+        _executeBuy(30 ether);
+        (bool s1,,) = _recenterAndLog("Buy#1");
+        (, int24 floorAfterBuy1,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("  Floor after buy1:", floorAfterBuy1);
+        console2.log("  Ratchet held:", floorAfterBuy1 == floorTickInit);
+
+        _executeBuy(20 ether);
+        (bool s2,,) = _recenterAndLog("Buy#2");
+        (, int24 floorAfterBuy2,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("  Floor after buy2:", floorAfterBuy2);
+        console2.log("  Ratchet held:", floorAfterBuy2 == floorTickInit);
+
+        // Phase 2: Sell back -> EthAbundance -> ratchet would be INACTIVE
+        _executeSell(kraiken.balanceOf(trader));
+        (bool s3, bool a3, int24 vwapTick3) = _recenterAndLog("Sell-back");
+        (, int24 floorAfterSell,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+
+        console2.log("Phase 2 (sell-back):");
+        console2.log("  EthAbundance fired:", a3);
+        console2.log("  Floor actual:", floorAfterSell);
+        console2.log("  VwapTick from event:", vwapTick3);
+        if (a3) {
+            console2.log("  PROPOSED: Floor would move to vwapTick during abundance");
+        }
+
+        // Phase 3: Buy again -> EthScarcity -> ratchet re-engages
+        _executeBuy(25 ether);
+        (bool s4,,) = _recenterAndLog("Buy#3");
+        (, int24 floorAfterBuy3,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("  EthScarcity fired:", s4);
+        console2.log("  Floor after buy3:", floorAfterBuy3);
+
+        console2.log("");
+        console2.log("=== CONDITIONAL RATCHET SUMMARY ===");
+        console2.log("Current: Floor permanently locked at:", floorTickInit);
+        console2.log("Proposed: Scarcity=locked, Abundance=free, re-lock on next scarcity");
+    }
+
+    /// @notice Diagnostic: buy->recenter->sell IL extraction.
+    /// Without a ratchet, trader CAN profit — this test documents the baseline.
+    function test_buyRecenterSell_baseline() public {
+        console2.log("=== Baseline: buy->recenter->sell (no ratchet) ===");
+
+        uint256 initWeth = weth.balanceOf(trader);
+
+        _executeBuy(78 ether);
+        (bool s1,,) = _recenterAndLog("Attack buy1");
+
+        _executeBuy(47 ether);
+        (bool s2,,) = _recenterAndLog("Attack buy2");
+
+        _executeBuy(40 ether);
+        _executeBuy(20 ether);
+        _recenterAndLog("Attack buy3+4");
+
+        _liquidateTrader();
+
+        int256 pnl = int256(weth.balanceOf(trader)) - int256(initWeth);
+        console2.log("Baseline PnL (ETH):", pnl / 1e18);
+        console2.log("Scarcity fired during buys:", s1, s2);
+        // No assertion — this test documents IL extraction without ratchet
+    }
+
+    /// @notice Diagnostic: sell-to-trigger-abundance then re-buy.
+    /// Documents baseline behavior without ratchet.
+    function test_sellToTriggerAbundance_baseline() public {
+        console2.log("=== Baseline: sell-to-trigger-abundance (no ratchet) ===");
+
+        uint256 initWeth = weth.balanceOf(trader);
+
+        // Phase 1: Buy 100 ETH worth
+        _executeBuy(50 ether);
+        _recenterAndLog("Setup buy1");
+        _executeBuy(50 ether);
+        _recenterAndLog("Setup buy2");
+
+        (, int24 floorAfterBuys,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("Floor after buys:", floorAfterBuys);
+
+        // Phase 2: Sell 90% to try to trigger abundance
+        uint256 krkBal = kraiken.balanceOf(trader);
+        _executeSell(krkBal * 90 / 100);
+        (bool s, bool a, int24 vwapTick) = _recenterAndLog("Post-90pct-sell");
+
+        (, int24 floorAfterSell,) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("After 90% sell:");
+        console2.log("  Scarcity:", s);
+        console2.log("  Abundance:", a);
+        console2.log("  Floor:", floorAfterSell);
+
+        if (a) {
+            console2.log("  Abundance fired - vwapTick:", vwapTick);
+        }
+
+        // Liquidate remaining
+        _liquidateTrader();
+        int256 pnl = int256(weth.balanceOf(trader)) - int256(initWeth);
+        console2.log("Final PnL:", pnl);
+        // No assertion — this test documents baseline without ratchet
+    }
+
+    // ================================================================
+    // HELPERS
+    // ================================================================
+
+    function _executeBuy(uint256 amount) internal {
+        if (weth.balanceOf(trader) < amount) return;
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), amount);
+        vm.stopPrank();
+        try swapExecutor.executeBuy(amount, trader) { } catch { }
+        _recoverStuck();
+    }
+
+    function _executeSell(uint256 krkAmount) internal {
+        if (krkAmount == 0) return;
+        uint256 bal = kraiken.balanceOf(trader);
+        if (bal < krkAmount) krkAmount = bal;
+        vm.startPrank(trader);
+        kraiken.transfer(address(swapExecutor), krkAmount);
+        vm.stopPrank();
+        try swapExecutor.executeSell(krkAmount, trader) { } catch { }
+        _recoverStuck();
+    }
+
+    function _recenterAndLog(string memory label) internal returns (bool sawScarcity, bool sawAbundance, int24 eventVwapTick) {
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.recordLogs();
+        vm.prank(fees);
+        try lm.recenter() { }
+        catch {
+            console2.log("  recenter FAILED:", label);
+            return (false, false, 0);
+        }
+
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        for (uint256 i = 0; i < logs.length; i++) {
+            if (logs[i].topics.length == 0) continue;
+            if (logs[i].topics[0] == SCARCITY_SIG) {
+                (int24 tick, uint256 ethBal, uint256 supply,, int24 vwapTick) = abi.decode(logs[i].data, (int24, uint256, uint256, uint256, int24));
+                sawScarcity = true;
+                eventVwapTick = vwapTick;
+                console2.log("  EthScarcity:", label);
+                console2.log("    tick:", tick);
+                console2.log("    ethBal:", ethBal / 1e18);
+                console2.log("    supply:", supply / 1e18);
+                console2.log("    vwapTick:", vwapTick);
+            } else if (logs[i].topics[0] == ABUNDANCE_SIG) {
+                (int24 tick, uint256 ethBal, uint256 supply,, int24 vwapTick) = abi.decode(logs[i].data, (int24, uint256, uint256, uint256, int24));
+                sawAbundance = true;
+                eventVwapTick = vwapTick;
+                console2.log("  EthAbundance:", label);
+                console2.log("    tick:", tick);
+                console2.log("    ethBal:", ethBal / 1e18);
+                console2.log("    supply:", supply / 1e18);
+                console2.log("    vwapTick:", vwapTick);
+            }
+        }
+
+        if (!sawScarcity && !sawAbundance) {
+            console2.log("  No scarcity/abundance:", label);
+        }
+    }
+
+    function _liquidateTrader() internal {
+        _recenterAndLog("Pre-liquidation");
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            _executeSell(remaining);
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            if (attempts % 3 == 2) {
+                _recenterAndLog("Liq recenter");
+            }
+            unchecked {
+                attempts++;
+            }
+        }
+    }
+
+    function _recoverStuck() internal {
+        uint256 sk = kraiken.balanceOf(address(swapExecutor));
+        if (sk > 0) {
+            vm.prank(address(swapExecutor));
+            kraiken.transfer(trader, sk);
+        }
+        uint256 sw = weth.balanceOf(address(swapExecutor));
+        if (sw > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, sw);
+        }
+    }
+}
diff --git a/onchain/test/FuzzingAnalyzerBugs.t.sol b/onchain/test/FuzzingAnalyzerBugs.t.sol
new file mode 100644
index 0000000..e60772e
--- /dev/null
+++ b/onchain/test/FuzzingAnalyzerBugs.t.sol
@@ -0,0 +1,1317 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import { SwapExecutor } from "../analysis/helpers/SwapExecutor.sol";
+import { Kraiken } from "../src/Kraiken.sol";
+import { LiquidityManager } from "../src/LiquidityManager.sol";
+import { ThreePositionStrategy } from "../src/abstracts/ThreePositionStrategy.sol";
+import { UniswapHelpers } from "../src/helpers/UniswapHelpers.sol";
+import { IWETH9 } from "../src/interfaces/IWETH9.sol";
+import { TestEnvironment } from "./helpers/TestBase.sol";
+import { ConfigurableOptimizer } from "./mocks/ConfigurableOptimizer.sol";
+import { IUniswapV3Factory } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
+import { IUniswapV3Pool } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol";
+import "forge-std/Test.sol";
+import "forge-std/console2.sol";
+
+/// @title FuzzingAnalyzerBugs
+/// @notice Tests verifying that the fuzzing analyzer measurements are correct
+contract FuzzingAnalyzerBugs is Test {
+    TestEnvironment testEnv;
+    IUniswapV3Factory factory;
+    IUniswapV3Pool pool;
+    IWETH9 weth;
+    Kraiken kraiken;
+    LiquidityManager lm;
+    SwapExecutor swapExecutor;
+    ConfigurableOptimizer optimizer;
+    bool token0isWeth;
+
+    address trader = makeAddr("trader");
+    address fees = makeAddr("fees");
+
+    function setUp() public {
+        testEnv = new TestEnvironment(fees);
+        factory = UniswapHelpers.deployUniswapFactory();
+
+        // Bear market params: CI=0.8e18, AS=0.1e18, AW=40, DD=0.2e18
+        optimizer = new ConfigurableOptimizer(8e17, 1e17, 40, 2e17);
+
+        (factory, pool, weth, kraiken,, lm,, token0isWeth) = testEnv.setupEnvironmentWithExistingFactory(factory, true, fees, address(optimizer));
+
+        swapExecutor = new SwapExecutor(pool, weth, kraiken, token0isWeth, lm, true);
+
+        // Fund LM
+        vm.deal(address(lm), 200 ether);
+        vm.prank(address(lm));
+        weth.deposit{ value: 100 ether }();
+
+        // Initial recenter
+        vm.prank(fees);
+        lm.recenter();
+    }
+
+    /// @notice Simple round trip: buy → recenter → sell. Trader should NOT profit.
+    function test_simpleRoundTrip_bearMarket() public {
+        // Fund trader
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        uint256 traderInitEth = weth.balanceOf(trader);
+        console2.log("Trader initial WETH:", traderInitEth / 1e18);
+
+        // Buy 30 ETH of KRAIKEN
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 30 ether);
+        vm.stopPrank();
+        uint256 bought = swapExecutor.executeBuy(30 ether, trader);
+        console2.log("WETH consumed by buy:", bought / 1e18);
+
+        // Recover any stuck WETH
+        uint256 stuckWeth = weth.balanceOf(address(swapExecutor));
+        if (stuckWeth > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, stuckWeth);
+        }
+
+        uint256 krkBalance = kraiken.balanceOf(trader);
+        console2.log("KRAIKEN received:", krkBalance / 1e18);
+
+        // Recenter
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        lm.recenter();
+
+        // Sell all KRAIKEN
+        vm.startPrank(trader);
+        kraiken.transfer(address(swapExecutor), krkBalance);
+        vm.stopPrank();
+        uint256 sold = swapExecutor.executeSell(krkBalance, trader);
+        console2.log("KRAIKEN consumed by sell:", sold / 1e18);
+
+        // Recover stuck tokens
+        uint256 stuckKrk = kraiken.balanceOf(address(swapExecutor));
+        if (stuckKrk > 0) {
+            vm.prank(address(swapExecutor));
+            kraiken.transfer(trader, stuckKrk);
+        }
+        stuckWeth = weth.balanceOf(address(swapExecutor));
+        if (stuckWeth > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, stuckWeth);
+        }
+
+        uint256 traderFinalEth = weth.balanceOf(trader);
+        uint256 traderFinalKrk = kraiken.balanceOf(trader);
+        int256 pnl = int256(traderFinalEth) - int256(traderInitEth);
+
+        console2.log("Trader final WETH:", traderFinalEth / 1e18);
+        console2.log("Trader unsold KRAIKEN:", traderFinalKrk / 1e18);
+        console2.log("Trader PnL (wei):", pnl);
+
+        // In a simple round trip, trader should lose (slippage + fees)
+        assertLe(pnl, 0, "Trader should not profit from simple round trip");
+    }
+
+    /// @notice Demonstrates the PnL leakage bug: leftover KRAIKEN inflates next run's profit
+    function test_pnlLeakage_withoutCleanup() public {
+        // === RUN 0: Buy a lot, partial liquidation ===
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        // Buy aggressively
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 80 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(80 ether, trader);
+
+        // Recover stuck WETH from partial buy
+        uint256 stuckW = weth.balanceOf(address(swapExecutor));
+        if (stuckW > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, stuckW);
+        }
+
+        uint256 krkAfterBuy = kraiken.balanceOf(trader);
+        console2.log("Run 0 - KRAIKEN after buy:", krkAfterBuy / 1e18);
+
+        // Recenter
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        // Partial liquidation: sell half
+        uint256 halfKrk = krkAfterBuy / 2;
+        if (halfKrk > 0) {
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), halfKrk);
+            vm.stopPrank();
+            swapExecutor.executeSell(halfKrk, trader);
+        }
+        // Recover stuck tokens
+        stuckW = weth.balanceOf(address(swapExecutor));
+        if (stuckW > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, stuckW);
+        }
+        uint256 stuckK = kraiken.balanceOf(address(swapExecutor));
+        if (stuckK > 0) {
+            vm.prank(address(swapExecutor));
+            kraiken.transfer(trader, stuckK);
+        }
+
+        uint256 run0FinalWeth = weth.balanceOf(trader);
+        uint256 run0LeftoverKrk = kraiken.balanceOf(trader);
+        int256 run0Pnl = int256(run0FinalWeth) - 200 ether;
+        console2.log("Run 0 - Final WETH:", run0FinalWeth / 1e18);
+        console2.log("Run 0 - Leftover KRK:", run0LeftoverKrk / 1e18);
+        console2.log("Run 0 - PnL (WETH only):", run0Pnl);
+
+        // === RUN 1 (WITHOUT CLEANUP - the old buggy behavior) ===
+        // Don't clean up! Just add more WETH on top.
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+        uint256 run1InitEth = weth.balanceOf(trader); // Includes old balance!
+
+        console2.log("Run 1 - Init WETH (includes old):", run1InitEth / 1e18);
+        console2.log("Run 1 - Carried KRK:", kraiken.balanceOf(trader) / 1e18);
+
+        // Recenter to build new liquidity
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        // Now sell the leftover KRAIKEN from run 0
+        uint256 carryKrk = kraiken.balanceOf(trader);
+        if (carryKrk > 0) {
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), carryKrk);
+            vm.stopPrank();
+            swapExecutor.executeSell(carryKrk, trader);
+
+            stuckW = weth.balanceOf(address(swapExecutor));
+            if (stuckW > 0) {
+                vm.prank(address(swapExecutor));
+                weth.transfer(trader, stuckW);
+            }
+            stuckK = kraiken.balanceOf(address(swapExecutor));
+            if (stuckK > 0) {
+                vm.prank(address(swapExecutor));
+                kraiken.transfer(trader, stuckK);
+            }
+        }
+
+        uint256 run1FinalEth = weth.balanceOf(trader);
+        int256 run1Pnl = int256(run1FinalEth) - int256(run1InitEth);
+        console2.log("Run 1 - Final WETH:", run1FinalEth / 1e18);
+        console2.log("Run 1 - PnL (without cleanup):", run1Pnl);
+
+        // The key insight: run1Pnl can be POSITIVE because it includes WETH from
+        // selling run 0's leftover KRAIKEN, which was never accounted for.
+        // This is the false positive that made 251/252 combos appear "unsafe".
+        if (run1Pnl > 0) {
+            console2.log("BUG CONFIRMED: Run 1 shows false profit from leftover KRAIKEN");
+        }
+
+        // True combined PnL across both runs should be negative
+        int256 totalPnl = run0Pnl + run1Pnl;
+        console2.log("Total PnL across both runs:", totalPnl);
+    }
+
+    /// @notice 10 cycles of buy→recenter→sell — does IL accumulation create profit?
+    function test_multiCycle_bearMarket() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        uint256 traderInitEth = weth.balanceOf(trader);
+        console2.log("=== Multi-cycle test (10 cycles) ===");
+        console2.log("Trader initial WETH:", traderInitEth / 1e18);
+
+        for (uint256 i = 0; i < 10; i++) {
+            uint256 wethBefore = weth.balanceOf(trader);
+            uint256 buyAmount = 20 ether;
+            if (wethBefore < buyAmount) {
+                console2.log("Cycle", i, "- skipped (insufficient WETH)");
+                break;
+            }
+
+            // Buy
+            vm.startPrank(trader);
+            weth.transfer(address(swapExecutor), buyAmount);
+            vm.stopPrank();
+            swapExecutor.executeBuy(buyAmount, trader);
+
+            // Recover stuck WETH from partial buy
+            uint256 sw = weth.balanceOf(address(swapExecutor));
+            if (sw > 0) {
+                vm.prank(address(swapExecutor));
+                weth.transfer(trader, sw);
+            }
+
+            uint256 krkBal = kraiken.balanceOf(trader);
+
+            // Recenter
+            vm.warp(block.timestamp + 1 hours);
+            vm.roll(block.number + 1);
+            vm.prank(fees);
+            try lm.recenter() { } catch { }
+
+            // Sell all KRAIKEN
+            if (krkBal > 0) {
+                vm.startPrank(trader);
+                kraiken.transfer(address(swapExecutor), krkBal);
+                vm.stopPrank();
+                try swapExecutor.executeSell(krkBal, trader) { } catch { }
+            }
+
+            // Recover stuck tokens
+            uint256 sk = kraiken.balanceOf(address(swapExecutor));
+            if (sk > 0) {
+                vm.prank(address(swapExecutor));
+                kraiken.transfer(trader, sk);
+            }
+            sw = weth.balanceOf(address(swapExecutor));
+            if (sw > 0) {
+                vm.prank(address(swapExecutor));
+                weth.transfer(trader, sw);
+            }
+
+            uint256 wethAfter = weth.balanceOf(trader);
+            uint256 krkLeft = kraiken.balanceOf(trader);
+            int256 cyclePnl = int256(wethAfter) - int256(wethBefore);
+            console2.log("Cycle", i);
+            console2.log("  PnL (wei):", cyclePnl);
+            console2.log("  KRK left:", krkLeft / 1e18);
+        }
+
+        // Final cleanup: sell any remaining KRAIKEN
+        uint256 finalKrk = kraiken.balanceOf(trader);
+        if (finalKrk > 0) {
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), finalKrk);
+            vm.stopPrank();
+            try swapExecutor.executeSell(finalKrk, trader) { } catch { }
+            uint256 sk = kraiken.balanceOf(address(swapExecutor));
+            if (sk > 0) {
+                vm.prank(address(swapExecutor));
+                kraiken.transfer(trader, sk);
+            }
+            uint256 sw = weth.balanceOf(address(swapExecutor));
+            if (sw > 0) {
+                vm.prank(address(swapExecutor));
+                weth.transfer(trader, sw);
+            }
+        }
+
+        uint256 traderFinalEth = weth.balanceOf(trader);
+        uint256 traderFinalKrk = kraiken.balanceOf(trader);
+        int256 totalPnl = int256(traderFinalEth) - int256(traderInitEth);
+        console2.log("=== Final ===");
+        console2.log("Final WETH:", traderFinalEth / 1e18);
+        console2.log("Unsold KRK:", traderFinalKrk / 1e18);
+        console2.log("Total PnL:", totalPnl);
+
+        // Multi-cycle should also show loss with bear params
+        assertLe(totalPnl, 0, "Trader should not profit even with multiple cycles");
+    }
+
+    /// @notice Same as sweep-like test but with CAPPED swaps (production behavior)
+    function test_sweepLikeRun_bearMarket_capped() public {
+        // Redeploy SwapExecutor with capped=false (uses LiquidityBoundaryHelper)
+        swapExecutor = new SwapExecutor(pool, weth, kraiken, token0isWeth, lm, false);
+
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        uint256 traderInitEth = weth.balanceOf(trader);
+        console2.log("=== Sweep-like run CAPPED (30 trades, 80% buy bias) ===");
+
+        for (uint256 i = 0; i < 30; i++) {
+            if (uint256(keccak256(abi.encodePacked(uint256(0), i, "recenter"))) % 3 == 0) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+
+            uint256 rand = uint256(keccak256(abi.encodePacked(uint256(0), i))) % 100;
+            if (rand < 80) {
+                uint256 amount = (20 * 1 ether) + (uint256(keccak256(abi.encodePacked(uint256(0), i, "buy"))) % (60 * 1 ether));
+                if (weth.balanceOf(trader) < amount) continue;
+                vm.startPrank(trader);
+                weth.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeBuy(amount, trader) { } catch { }
+                vm.stopPrank();
+                _recoverStuck();
+            } else {
+                uint256 krkBal = kraiken.balanceOf(trader);
+                if (krkBal == 0) continue;
+                uint256 pct = 20 + (uint256(keccak256(abi.encodePacked(uint256(0), i, "sell"))) % 60);
+                uint256 amount = krkBal * pct / 100;
+                if (amount == 0) continue;
+                vm.startPrank(trader);
+                kraiken.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeSell(amount, trader) { } catch { }
+                vm.stopPrank();
+                _recoverStuck();
+            }
+        }
+
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        // Liquidate
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+            try swapExecutor.executeSell(remaining, trader) { } catch { }
+            _recoverStuck();
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+        _recoverStuck();
+
+        uint256 traderFinalEth = weth.balanceOf(trader);
+        int256 pnl = int256(traderFinalEth) - int256(traderInitEth);
+        console2.log("Final WETH:", traderFinalEth / 1e18);
+        console2.log("Unsold KRK:", kraiken.balanceOf(trader) / 1e18);
+        console2.log("PnL (wei):", pnl);
+
+        // With capped swaps + bear params, trader should NOT profit
+        assertLe(pnl, 0, "Trader should not profit with capped swaps + bear params");
+    }
+
+    /// @notice Conservation check: total system WETH is consistent
+    function test_systemConservation() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        // Track WETH total supply (all holders)
+        uint256 wethSupplyBefore = weth.balanceOf(trader) + weth.balanceOf(address(lm)) + weth.balanceOf(address(pool)) + weth.balanceOf(address(swapExecutor))
+            + weth.balanceOf(address(0xdead));
+        uint256 lmEthBefore = address(lm).balance;
+        console2.log("WETH supply before:", wethSupplyBefore / 1e18);
+        console2.log("LM native ETH:", lmEthBefore / 1e18);
+
+        // Do 10 trades with buys and recenters
+        for (uint256 i = 0; i < 10; i++) {
+            if (i % 3 == 0) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+
+            uint256 amount = 20 ether;
+            if (weth.balanceOf(trader) >= amount) {
+                vm.startPrank(trader);
+                weth.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeBuy(amount, trader) { } catch { }
+                vm.stopPrank();
+            }
+        }
+
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        uint256 wethSupplyAfter = weth.balanceOf(trader) + weth.balanceOf(address(lm)) + weth.balanceOf(address(pool)) + weth.balanceOf(address(swapExecutor))
+            + weth.balanceOf(address(0xdead)) + weth.balanceOf(fees);
+        uint256 lmEthAfter = address(lm).balance;
+        console2.log("WETH supply after:", wethSupplyAfter / 1e18);
+        console2.log("LM native ETH after:", lmEthAfter / 1e18);
+
+        // Total WETH should equal initial + any ETH that was converted
+        uint256 totalEthConverted = lmEthBefore - lmEthAfter;
+        console2.log("ETH converted to WETH:", totalEthConverted / 1e18);
+        console2.log("Expected WETH supply:", (wethSupplyBefore + totalEthConverted) / 1e18);
+
+        assertEq(wethSupplyAfter, wethSupplyBefore + totalEthConverted, "WETH total supply should be conserved (accounting for ETH->WETH conversion)");
+    }
+
+    /// @notice Mimics sweep run: 30 trades with 80% buy bias, bear params
+    function test_sweepLikeRun_bearMarket() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        uint256 traderInitEth = weth.balanceOf(trader);
+        console2.log("=== Sweep-like run (30 trades, 80% buy bias) ===");
+
+        uint256 recenters;
+        uint256 buysFailed;
+        uint256 sellsFailed;
+
+        for (uint256 i = 0; i < 30; i++) {
+            // 1/3 chance of recenter
+            if (uint256(keccak256(abi.encodePacked(uint256(0), i, "recenter"))) % 3 == 0) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() {
+                    recenters++;
+                } catch { }
+            }
+
+            uint256 rand = uint256(keccak256(abi.encodePacked(uint256(0), i))) % 100;
+            if (rand < 80) {
+                // Buy
+                uint256 amount = (20 * 1 ether) + (uint256(keccak256(abi.encodePacked(uint256(0), i, "buy"))) % (60 * 1 ether));
+                if (weth.balanceOf(trader) < amount) {
+                    buysFailed++;
+                    continue;
+                }
+
+                vm.startPrank(trader);
+                weth.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeBuy(amount, trader) returns (uint256 a) {
+                    vm.stopPrank();
+                    if (a == 0) buysFailed++;
+                } catch {
+                    vm.stopPrank();
+                    buysFailed++;
+                }
+            } else {
+                // Sell
+                uint256 krkBal = kraiken.balanceOf(trader);
+                if (krkBal == 0) {
+                    sellsFailed++;
+                    continue;
+                }
+                uint256 pct = 20 + (uint256(keccak256(abi.encodePacked(uint256(0), i, "sell"))) % 60);
+                uint256 amount = krkBal * pct / 100;
+                if (amount == 0) {
+                    sellsFailed++;
+                    continue;
+                }
+
+                vm.startPrank(trader);
+                kraiken.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeSell(amount, trader) returns (uint256 a) {
+                    vm.stopPrank();
+                    if (a == 0) sellsFailed++;
+                } catch {
+                    vm.stopPrank();
+                    sellsFailed++;
+                }
+            }
+        }
+
+        // Final recenter
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() {
+            recenters++;
+        } catch { }
+
+        console2.log("Trades done. Recenters:", recenters);
+        console2.log("Buys failed:", buysFailed);
+        console2.log("Sells failed:", sellsFailed);
+
+        // Liquidate holdings (same as sweep)
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            uint256 wBefore = weth.balanceOf(trader);
+
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+
+            try swapExecutor.executeSell(remaining, trader) {
+                if (weth.balanceOf(trader) <= wBefore) {
+                    _recoverStuck();
+                    break;
+                }
+            } catch {
+                _recoverStuck();
+                break;
+            }
+
+            _recoverStuck();
+
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+
+        // Also recover any stuck WETH from buys
+        _recoverStuck();
+
+        uint256 traderFinalEth = weth.balanceOf(trader);
+        uint256 traderFinalKrk = kraiken.balanceOf(trader);
+        int256 pnl = int256(traderFinalEth) - int256(traderInitEth);
+
+        console2.log("=== Results ===");
+        console2.log("Final WETH:", traderFinalEth / 1e18);
+        console2.log("Unsold KRK:", traderFinalKrk / 1e18);
+        console2.log("PnL (wei):", pnl);
+        console2.log("SwapExec WETH:", weth.balanceOf(address(swapExecutor)) / 1e18);
+        console2.log("SwapExec KRK:", kraiken.balanceOf(address(swapExecutor)) / 1e18);
+
+        // Without ratchet, trader may profit from IL extraction via buy->recenter->sell cycles
+        // This test documents the baseline behavior
+        console2.log("Baseline sweep PnL (no ratchet):", pnl);
+    }
+
+    function _recoverStuck() internal {
+        uint256 sk = kraiken.balanceOf(address(swapExecutor));
+        if (sk > 0) {
+            vm.prank(address(swapExecutor));
+            kraiken.transfer(trader, sk);
+        }
+        uint256 sw = weth.balanceOf(address(swapExecutor));
+        if (sw > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, sw);
+        }
+    }
+
+    /// @notice Total system WETH = all holders + LM native ETH (before wrapping)
+    function _systemWeth() internal view returns (uint256) {
+        return weth.balanceOf(trader) + weth.balanceOf(address(lm)) + weth.balanceOf(address(pool)) + weth.balanceOf(address(swapExecutor))
+            + weth.balanceOf(address(0xdead)) + weth.balanceOf(fees) + address(lm).balance;
+    }
+
+    /// @notice Trade-by-trade diagnostic: replicate sweep run 0 with verbose logging
+    /// Uses exact same seeds and pattern as ParameterSweepFuzzing._executeRun(0)
+    /// Bear params: CI=0.8e18, AS=0.1e18, AW=40, DD=0.2e18, buyBias=80
+    function test_tradeByTrade_diagnostic() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        uint256 traderInitEth = weth.balanceOf(trader);
+        uint256 systemStart = _systemWeth();
+
+        console2.log("=== TRADE-BY-TRADE DIAGNOSTIC ===");
+        console2.log("traderInitWETH:", traderInitEth);
+        console2.log("systemWETH:", systemStart);
+        console2.log("LM native ETH:", address(lm).balance);
+        console2.log("LM WETH:", weth.balanceOf(address(lm)));
+        console2.log("pool WETH:", weth.balanceOf(address(pool)));
+
+        (, int24 startTick,,,,,) = pool.slot0();
+        console2.log("startTick:", startTick);
+
+        bool crossedAbove200 = false;
+        uint256 runIndex = 0;
+
+        for (uint256 i = 0; i < 30; i++) {
+            // 1/3 chance of recenter (same hash as sweep)
+            if (uint256(keccak256(abi.encodePacked(runIndex, i, "recenter"))) % 3 == 0) {
+                uint256 sysBeforeRec = _systemWeth();
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() {
+                    uint256 sysAfterRec = _systemWeth();
+                    (, int24 tick,,,,,) = pool.slot0();
+                    console2.log("---");
+                    console2.log("RECENTER ok  tick:", tick);
+                    console2.log("  tW:", weth.balanceOf(trader));
+                    console2.log("  tK:", kraiken.balanceOf(trader));
+                    if (sysAfterRec != sysBeforeRec) {
+                        int256 leak = int256(sysAfterRec) - int256(sysBeforeRec);
+                        console2.log("  !! SYS WETH CHANGED by:", leak);
+                    }
+                } catch {
+                    console2.log("--- RECENTER failed at trade", i);
+                }
+            }
+
+            uint256 rand = uint256(keccak256(abi.encodePacked(runIndex, i))) % 100;
+            if (rand < 80) {
+                // Buy (same amount calc as sweep)
+                uint256 amount = (20 * 1 ether) + (uint256(keccak256(abi.encodePacked(runIndex, i, "buy"))) % (60 * 1 ether));
+                uint256 traderWethBefore = weth.balanceOf(trader);
+                uint256 traderKrkBefore = kraiken.balanceOf(trader);
+
+                if (traderWethBefore < amount) {
+                    console2.log("T", i);
+                    console2.log("  BUY_SKIP need:", amount / 1e18);
+                    console2.log("  have:", traderWethBefore / 1e18);
+                    continue;
+                }
+
+                uint256 sysBefore = _systemWeth();
+
+                vm.startPrank(trader);
+                weth.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeBuy(amount, trader) returns (uint256 consumed) {
+                    vm.stopPrank();
+                    _recoverStuck();
+
+                    uint256 traderWethAfter = weth.balanceOf(trader);
+                    uint256 traderKrkAfter = kraiken.balanceOf(trader);
+                    uint256 sysAfter = _systemWeth();
+                    (, int24 tick,,,,,) = pool.slot0();
+
+                    console2.log("T", i);
+                    console2.log("  BUY amt:", amount / 1e18);
+                    console2.log("  consumed:", consumed / 1e18);
+                    console2.log("  tW:", traderWethAfter);
+                    console2.log("  tK:", traderKrkAfter);
+                    console2.log("  tick:", tick);
+
+                    int256 wethDelta = int256(traderWethAfter) - int256(traderWethBefore);
+                    int256 krkDelta = int256(traderKrkAfter) - int256(traderKrkBefore);
+                    console2.log("  dW:", wethDelta);
+                    console2.log("  dK:", krkDelta);
+
+                    if (sysAfter != sysBefore) {
+                        int256 leak = int256(sysAfter) - int256(sysBefore);
+                        console2.log("  !! SYS LEAK:", leak);
+                    }
+
+                    if (!crossedAbove200 && traderWethAfter > 200 ether) {
+                        crossedAbove200 = true;
+                        console2.log("  *** CROSSED 200 WETH ***");
+                    }
+                } catch {
+                    vm.stopPrank();
+                    _recoverStuck();
+                    console2.log("T", i);
+                    console2.log("  BUY_FAIL amt:", amount / 1e18);
+                }
+            } else {
+                // Sell (same calc as sweep)
+                uint256 krkBal = kraiken.balanceOf(trader);
+                if (krkBal == 0) {
+                    console2.log("T", i);
+                    console2.log("  SELL_SKIP (0 KRK)");
+                    continue;
+                }
+                uint256 pct = 20 + (uint256(keccak256(abi.encodePacked(runIndex, i, "sell"))) % 60);
+                uint256 amount = krkBal * pct / 100;
+                if (amount == 0) {
+                    console2.log("T", i);
+                    console2.log("  SELL_SKIP (0 amt)");
+                    continue;
+                }
+
+                uint256 traderWethBefore = weth.balanceOf(trader);
+                uint256 traderKrkBefore = kraiken.balanceOf(trader);
+                uint256 sysBefore = _systemWeth();
+
+                vm.startPrank(trader);
+                kraiken.transfer(address(swapExecutor), amount);
+                try swapExecutor.executeSell(amount, trader) returns (uint256 consumed) {
+                    vm.stopPrank();
+                    _recoverStuck();
+
+                    uint256 traderWethAfter = weth.balanceOf(trader);
+                    uint256 traderKrkAfter = kraiken.balanceOf(trader);
+                    uint256 sysAfter = _systemWeth();
+                    (, int24 tick,,,,,) = pool.slot0();
+
+                    console2.log("T", i);
+                    console2.log("  SELL pct:", pct);
+                    console2.log("  amt:", amount / 1e18);
+                    console2.log("  consumed:", consumed / 1e18);
+                    console2.log("  tW:", traderWethAfter);
+                    console2.log("  tK:", traderKrkAfter);
+                    console2.log("  tick:", tick);
+
+                    int256 wethDelta = int256(traderWethAfter) - int256(traderWethBefore);
+                    console2.log("  dW:", wethDelta);
+
+                    if (sysAfter != sysBefore) {
+                        int256 leak = int256(sysAfter) - int256(sysBefore);
+                        console2.log("  !! SYS LEAK:", leak);
+                    }
+
+                    if (!crossedAbove200 && traderWethAfter > 200 ether) {
+                        crossedAbove200 = true;
+                        console2.log("  *** CROSSED 200 WETH ***");
+                    }
+                } catch {
+                    vm.stopPrank();
+                    _recoverStuck();
+                    console2.log("T", i);
+                    console2.log("  SELL_FAIL amt:", amount / 1e18);
+                }
+            }
+        }
+
+        console2.log("=== PRE-LIQUIDATION ===");
+        console2.log("tW:", weth.balanceOf(trader));
+        console2.log("tK:", kraiken.balanceOf(trader));
+        console2.log("seW:", weth.balanceOf(address(swapExecutor)));
+        console2.log("seK:", kraiken.balanceOf(address(swapExecutor)));
+
+        // Final recenter
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        // Liquidate (same as sweep)
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            uint256 wBefore = weth.balanceOf(trader);
+
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+
+            try swapExecutor.executeSell(remaining, trader) {
+                if (weth.balanceOf(trader) <= wBefore) {
+                    _recoverStuck();
+                    break;
+                }
+            } catch {
+                _recoverStuck();
+                break;
+            }
+
+            _recoverStuck();
+
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+        _recoverStuck();
+
+        uint256 traderFinalEth = weth.balanceOf(trader);
+        uint256 traderFinalKrk = kraiken.balanceOf(trader);
+        int256 pnl = int256(traderFinalEth) - int256(traderInitEth);
+        uint256 systemEnd = _systemWeth();
+
+        console2.log("=== FINAL ===");
+        console2.log("traderWETH:", traderFinalEth);
+        console2.log("traderKRK:", traderFinalKrk);
+        console2.log("PnL:", pnl);
+        console2.log("systemStart:", systemStart);
+        console2.log("systemEnd:", systemEnd);
+        int256 sysChange = int256(systemEnd) - int256(systemStart);
+        console2.log("sysChange:", sysChange);
+
+        // System WETH should be conserved (no ETH created from nothing)
+        // If sysChange != 0, ETH is leaking in or out
+        if (sysChange != 0) {
+            console2.log("!! SYSTEM WETH NOT CONSERVED !!");
+        }
+    }
+
+    /// @notice Compare: single big buy vs multi-buy with recenters
+    /// If single big buy also profits, the issue is trade size.
+    /// If only multi-buy profits, recenters are creating the opportunity.
+    function test_singleBigBuy_vs_multiBuy() public {
+        // === SCENARIO A: Single big buy (185 ETH) → recenter → sell all ===
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        uint256 initA = weth.balanceOf(trader);
+
+        // Buy 185 ETH in one shot
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 185 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(185 ether, trader);
+        _recoverStuck();
+
+        uint256 krkA = kraiken.balanceOf(trader);
+        (, int24 tickAfterBuy,,,,,) = pool.slot0();
+        console2.log("=== SCENARIO A: Single 185 ETH buy ===");
+        console2.log("KRK received:", krkA);
+        console2.log("tick after buy:", tickAfterBuy);
+        console2.log("tW after buy:", weth.balanceOf(trader));
+
+        // Recenter
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        (, int24 tickAfterRec,,,,,) = pool.slot0();
+        console2.log("tick after recenter:", tickAfterRec);
+
+        // Sell all KRK
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+            try swapExecutor.executeSell(remaining, trader) { } catch { }
+            _recoverStuck();
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+        _recoverStuck();
+
+        int256 pnlA = int256(weth.balanceOf(trader)) - int256(initA);
+        console2.log("PnL A (single buy):", pnlA);
+        console2.log("Unsold KRK A:", kraiken.balanceOf(trader));
+    }
+
+    /// @notice Isolate: 2 buys with recenter between them
+    function test_twoBuys_withRecenter() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+        uint256 init = weth.balanceOf(trader);
+
+        // Buy #1: 78 ETH
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 78 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(78 ether, trader);
+        _recoverStuck();
+
+        (, int24 t1,,,,,) = pool.slot0();
+        console2.log("After buy1: tick", t1);
+        console2.log("  tW:", weth.balanceOf(trader));
+        console2.log("  tK:", kraiken.balanceOf(trader));
+
+        // Recenter
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { }
+        catch {
+            console2.log("  recenter1 FAILED");
+        }
+
+        // Buy #2: 47 ETH
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 47 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(47 ether, trader);
+        _recoverStuck();
+
+        (, int24 t2,,,,,) = pool.slot0();
+        console2.log("After buy2: tick", t2);
+        console2.log("  tW:", weth.balanceOf(trader));
+        console2.log("  tK:", kraiken.balanceOf(trader));
+
+        // Recenter again
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { }
+        catch {
+            console2.log("  recenter2 FAILED");
+        }
+
+        // Sell ALL
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+            try swapExecutor.executeSell(remaining, trader) { } catch { }
+            _recoverStuck();
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+        _recoverStuck();
+
+        int256 pnl = int256(weth.balanceOf(trader)) - int256(init);
+        console2.log("=== 2-buy result ===");
+        console2.log("PnL:", pnl);
+        console2.log("Unsold KRK:", kraiken.balanceOf(trader));
+    }
+
+    /// @notice 4 buys matching sweep T0-T5 exactly, with recenters
+    function test_fourBuys_withRecenters() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+        uint256 init = weth.balanceOf(trader);
+        uint256 sysStart = _systemWeth();
+
+        // Replicate the sweep's first 4 buys exactly
+        uint256[4] memory buyAmounts = [uint256(78 ether), 47 ether, 40 ether, 20 ether];
+        // Recenters happen after T0 and T1 (from the diagnostic output)
+        bool[4] memory recenterAfter = [true, true, false, false];
+
+        for (uint256 i = 0; i < 4; i++) {
+            vm.startPrank(trader);
+            weth.transfer(address(swapExecutor), buyAmounts[i]);
+            vm.stopPrank();
+            swapExecutor.executeBuy(buyAmounts[i], trader);
+            _recoverStuck();
+
+            (, int24 tick,,,,,) = pool.slot0();
+            console2.log("Buy", i);
+            console2.log("  amt:", buyAmounts[i] / 1e18);
+            console2.log("  tick:", tick);
+            console2.log("  tW:", weth.balanceOf(trader));
+            console2.log("  tK:", kraiken.balanceOf(trader));
+
+            if (recenterAfter[i]) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() {
+                    console2.log("  recenter OK");
+                } catch {
+                    console2.log("  recenter FAILED");
+                }
+            }
+        }
+
+        // Final recenter before selling
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        // Sell ALL
+        uint256 remaining = kraiken.balanceOf(trader);
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+            try swapExecutor.executeSell(remaining, trader) { } catch { }
+            _recoverStuck();
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+        _recoverStuck();
+
+        int256 pnl = int256(weth.balanceOf(trader)) - int256(init);
+        uint256 sysEnd = _systemWeth();
+
+        console2.log("=== 4-buy result ===");
+        console2.log("PnL:", pnl);
+        console2.log("Unsold KRK:", kraiken.balanceOf(trader));
+        console2.log("sysStart:", sysStart);
+        console2.log("sysEnd:", sysEnd);
+    }
+
+    /// @notice Deep diagnostic: track position layout, VWAP tick, and ETH distribution
+    /// around each recenter to understand WHY recenters between buys create profit.
+    function test_recenterMechanism_diagnostic() public {
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        console2.log("=== INITIAL STATE (after setUp recenter) ===");
+        _logPositions("INIT");
+
+        // --- Buy #1: 78 ETH ---
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 78 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(78 ether, trader);
+        _recoverStuck();
+
+        console2.log("=== AFTER BUY1 (78 ETH) ===");
+        _logPositions("BUY1");
+        console2.log("  tW:", weth.balanceOf(trader));
+        console2.log("  tK:", kraiken.balanceOf(trader) / 1e18);
+
+        // --- Recenter #1 ---
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.recordLogs();
+        vm.prank(fees);
+        lm.recenter();
+        _logRecenterEvents();
+
+        console2.log("=== AFTER RECENTER1 ===");
+        _logPositions("REC1");
+
+        // --- Buy #2: 47 ETH ---
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 47 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(47 ether, trader);
+        _recoverStuck();
+
+        console2.log("=== AFTER BUY2 (47 ETH) ===");
+        _logPositions("BUY2");
+        console2.log("  tW:", weth.balanceOf(trader));
+        console2.log("  tK:", kraiken.balanceOf(trader) / 1e18);
+
+        // --- Recenter #2 ---
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.recordLogs();
+        vm.prank(fees);
+        lm.recenter();
+        _logRecenterEvents();
+
+        console2.log("=== AFTER RECENTER2 ===");
+        _logPositions("REC2");
+
+        // --- Buy #3: 40 ETH ---
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 40 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(40 ether, trader);
+        _recoverStuck();
+
+        console2.log("=== AFTER BUY3 (40 ETH) ===");
+        _logPositions("BUY3");
+        console2.log("  tW:", weth.balanceOf(trader));
+        console2.log("  tK:", kraiken.balanceOf(trader) / 1e18);
+
+        // --- Recenter #3 ---
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.recordLogs();
+        vm.prank(fees);
+        lm.recenter();
+        _logRecenterEvents();
+
+        console2.log("=== AFTER RECENTER3 ===");
+        _logPositions("REC3");
+
+        // --- Now sell everything ---
+        console2.log("=== SELLING ALL KRK ===");
+        uint256 totalKrk = kraiken.balanceOf(trader);
+        console2.log("  KRK to sell:", totalKrk / 1e18);
+        console2.log("  WETH before sell:", weth.balanceOf(trader));
+
+        uint256 remaining = totalKrk;
+        uint256 attempts;
+        while (remaining > 0 && attempts < 20) {
+            uint256 prev = remaining;
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), remaining);
+            vm.stopPrank();
+            try swapExecutor.executeSell(remaining, trader) { } catch { }
+            _recoverStuck();
+            if (attempts % 3 == 2) {
+                vm.warp(block.timestamp + 1 hours);
+                vm.roll(block.number + 1);
+                vm.prank(fees);
+                try lm.recenter() { } catch { }
+            }
+            remaining = kraiken.balanceOf(trader);
+            if (remaining >= prev) break;
+            unchecked {
+                attempts++;
+            }
+        }
+        _recoverStuck();
+
+        console2.log("=== AFTER SELL ALL ===");
+        _logPositions("SOLD");
+        int256 pnl = int256(weth.balanceOf(trader)) - 200 ether;
+        console2.log("  PnL:", pnl);
+        console2.log("  tW:", weth.balanceOf(trader));
+        console2.log("  unsold KRK:", kraiken.balanceOf(trader));
+        console2.log("  sysWeth:", _systemWeth());
+    }
+
+    function _logPositions(string memory label) internal view {
+        (, int24 currentTick,,,,,) = pool.slot0();
+        console2.log("  currentTick:", currentTick);
+
+        // Floor position
+        (uint128 floorLiq, int24 floorLower, int24 floorUpper) = lm.positions(ThreePositionStrategy.Stage.FLOOR);
+        console2.log("  FLOOR: [", floorLower);
+        console2.log("         ,", floorUpper);
+        console2.log("         ] liq:", uint256(floorLiq));
+
+        // Anchor position
+        (uint128 anchorLiq, int24 anchorLower, int24 anchorUpper) = lm.positions(ThreePositionStrategy.Stage.ANCHOR);
+        console2.log("  ANCHOR: [", anchorLower);
+        console2.log("          ,", anchorUpper);
+        console2.log("          ] liq:", uint256(anchorLiq));
+
+        // Discovery position
+        (uint128 discLiq, int24 discLower, int24 discUpper) = lm.positions(ThreePositionStrategy.Stage.DISCOVERY);
+        console2.log("  DISC: [", discLower);
+        console2.log("        ,", discUpper);
+        console2.log("        ] liq:", uint256(discLiq));
+
+        // ETH distribution
+        uint256 lmEth = address(lm).balance + weth.balanceOf(address(lm));
+        uint256 poolWeth = weth.balanceOf(address(pool));
+        console2.log("  lmEth:", lmEth);
+        console2.log("  poolWeth:", poolWeth);
+
+        // VWAP
+        uint256 vwapX96 = lm.getVWAP();
+        uint256 adjVwapX96 = lm.getAdjustedVWAP(8e17); // CI=0.8e18
+        console2.log("  vwapX96:", vwapX96);
+        console2.log("  adjVwapX96:", adjVwapX96);
+        console2.log("  cumVolume:", lm.cumulativeVolume());
+    }
+
+    function _logRecenterEvents() internal {
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        bytes32 scarcitySig = keccak256("EthScarcity(int24,uint256,uint256,uint256,int24)");
+        bytes32 abundanceSig = keccak256("EthAbundance(int24,uint256,uint256,uint256,int24)");
+
+        for (uint256 i = 0; i < logs.length; i++) {
+            if (logs[i].topics.length > 0) {
+                if (logs[i].topics[0] == scarcitySig) {
+                    (int24 tick, uint256 ethBal, uint256 supply, uint256 vwap, int24 vwapTick) =
+                        abi.decode(logs[i].data, (int24, uint256, uint256, uint256, int24));
+                    console2.log("  EVENT EthScarcity:");
+                    console2.log("    tick:", tick);
+                    console2.log("    ethBal:", ethBal);
+                    console2.log("    supply:", supply);
+                    console2.log("    vwapTick:", vwapTick);
+                } else if (logs[i].topics[0] == abundanceSig) {
+                    (int24 tick, uint256 ethBal, uint256 supply, uint256 vwap, int24 vwapTick) =
+                        abi.decode(logs[i].data, (int24, uint256, uint256, uint256, int24));
+                    console2.log("  EVENT EthAbundance:");
+                    console2.log("    tick:", tick);
+                    console2.log("    ethBal:", ethBal);
+                    console2.log("    supply:", supply);
+                    console2.log("    vwapTick:", vwapTick);
+                }
+            }
+        }
+    }
+
+    /// @notice Verifies that with proper cleanup, no false profits appear
+    function test_noFalseProfit_withCleanup() public {
+        // === RUN 0 ===
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+
+        vm.startPrank(trader);
+        weth.transfer(address(swapExecutor), 80 ether);
+        vm.stopPrank();
+        swapExecutor.executeBuy(80 ether, trader);
+
+        uint256 stuckW = weth.balanceOf(address(swapExecutor));
+        if (stuckW > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, stuckW);
+        }
+
+        vm.warp(block.timestamp + 1 hours);
+        vm.roll(block.number + 1);
+        vm.prank(fees);
+        try lm.recenter() { } catch { }
+
+        // Partial liquidation
+        uint256 halfKrk = kraiken.balanceOf(trader) / 2;
+        if (halfKrk > 0) {
+            vm.startPrank(trader);
+            kraiken.transfer(address(swapExecutor), halfKrk);
+            vm.stopPrank();
+            swapExecutor.executeSell(halfKrk, trader);
+        }
+        stuckW = weth.balanceOf(address(swapExecutor));
+        if (stuckW > 0) {
+            vm.prank(address(swapExecutor));
+            weth.transfer(trader, stuckW);
+        }
+        uint256 stuckK = kraiken.balanceOf(address(swapExecutor));
+        if (stuckK > 0) {
+            vm.prank(address(swapExecutor));
+            kraiken.transfer(trader, stuckK);
+        }
+
+        // === CLEANUP (the fix) ===
+        uint256 leftoverWeth = weth.balanceOf(trader);
+        if (leftoverWeth > 0) {
+            vm.prank(trader);
+            weth.transfer(address(0xdead), leftoverWeth);
+        }
+        uint256 leftoverKraiken = kraiken.balanceOf(trader);
+        if (leftoverKraiken > 0) {
+            vm.prank(trader);
+            kraiken.transfer(address(0xdead), leftoverKraiken);
+        }
+
+        // === RUN 1 (WITH CLEANUP) ===
+        vm.deal(trader, 200 ether);
+        vm.prank(trader);
+        weth.deposit{ value: 200 ether }();
+        uint256 run1InitEth = weth.balanceOf(trader);
+        uint256 run1InitKrk = kraiken.balanceOf(trader);
+
+        assertEq(run1InitEth, 200 ether, "Should start with exactly 200 WETH");
+        assertEq(run1InitKrk, 0, "Should start with 0 KRAIKEN");
+
+        console2.log("Run 1 (clean) - Init WETH:", run1InitEth / 1e18);
+        console2.log("Run 1 (clean) - Init KRK:", run1InitKrk);
+
+        // No trades in run 1 — just check starting state is clean
+        int256 pnl = int256(weth.balanceOf(trader)) - int256(run1InitEth);
+        assertEq(pnl, 0, "PnL should be 0 with no trades and clean state");
+    }
+}
diff --git a/onchain/test/OptimizerV3.t.sol b/onchain/test/OptimizerV3.t.sol
new file mode 100644
index 0000000..7ac7be1
--- /dev/null
+++ b/onchain/test/OptimizerV3.t.sol
@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import { OptimizerV3 } from "../src/OptimizerV3.sol";
+import { Stake } from "../src/Stake.sol";
+import "forge-std/Test.sol";
+
+contract OptimizerV3Test is Test {
+    OptimizerV3 optimizer;
+
+    // TAX_RATES from Stake.sol
+    uint256[30] TAX_RATES =
+        [uint256(1), 3, 5, 8, 12, 18, 24, 30, 40, 50, 60, 80, 100, 130, 180, 250, 320, 420, 540, 700, 920, 1200, 1600, 2000, 2600, 3400, 4400, 5700, 7500, 9700];
+    uint256 constant MAX_TAX = 9700;
+
+    function setUp() public {
+        // Deploy without initialization (we only test pure functions)
+        optimizer = new OptimizerV3();
+    }
+
+    function _normalizedTaxRate(uint256 taxRateIndex) internal view returns (uint256) {
+        return TAX_RATES[taxRateIndex] * 1e18 / MAX_TAX;
+    }
+
+    function _percentageStaked(uint256 pct) internal pure returns (uint256) {
+        return pct * 1e18 / 100;
+    }
+
+    // ==================== Always Bear (staked <= 91%) ====================
+
+    function testAlwaysBearAt0Percent() public view {
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            assertFalse(optimizer.isBullMarket(0, _normalizedTaxRate(taxIdx)), "0% staked should always be bear");
+        }
+    }
+
+    function testAlwaysBearAt50Percent() public view {
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            assertFalse(optimizer.isBullMarket(_percentageStaked(50), _normalizedTaxRate(taxIdx)), "50% staked should always be bear");
+        }
+    }
+
+    function testAlwaysBearAt91Percent() public view {
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            assertFalse(optimizer.isBullMarket(_percentageStaked(91), _normalizedTaxRate(taxIdx)), "91% staked should always be bear");
+        }
+    }
+
+    function testAlwaysBearAt39Percent() public view {
+        assertFalse(optimizer.isBullMarket(_percentageStaked(39), _normalizedTaxRate(0)), "39% staked should be bear");
+    }
+
+    function testAlwaysBearAt80Percent() public view {
+        assertFalse(optimizer.isBullMarket(_percentageStaked(80), _normalizedTaxRate(0)), "80% staked should be bear even with lowest tax");
+    }
+
+    // ==================== 92% Boundary ====================
+
+    function testBoundary92PercentLowestTax() public view {
+        // deltaS=8, effIdx=0 → penalty = 512*0/20 = 0 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(92), _normalizedTaxRate(0)), "92% staked, lowest tax should be bull");
+    }
+
+    function testBoundary92PercentTaxIdx1() public view {
+        // deltaS=8, effIdx=1 → penalty = 512*1/20 = 25 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(92), _normalizedTaxRate(1)), "92% staked, taxIdx=1 should be bull");
+    }
+
+    function testBoundary92PercentTaxIdx2() public view {
+        // deltaS=8, effIdx=2 → penalty = 512*2/20 = 51 >= 50 → BEAR
+        assertFalse(optimizer.isBullMarket(_percentageStaked(92), _normalizedTaxRate(2)), "92% staked, taxIdx=2 should be bear");
+    }
+
+    function testBoundary92PercentHighTax() public view {
+        // deltaS=8, effIdx=29 → penalty = 512*29/20 = 742 → BEAR
+        assertFalse(optimizer.isBullMarket(_percentageStaked(92), _normalizedTaxRate(29)), "92% staked, max tax should be bear");
+    }
+
+    // ==================== 95% Staked ====================
+
+    function testAt95PercentLowTax() public view {
+        // deltaS=5, effIdx=0 → penalty = 125*0/20 = 0 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(95), _normalizedTaxRate(0)), "95% staked, lowest tax should be bull");
+    }
+
+    function testAt95PercentTaxIdx7() public view {
+        // deltaS=5, effIdx=7 → penalty = 125*7/20 = 43 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(95), _normalizedTaxRate(7)), "95% staked, taxIdx=7 should be bull");
+    }
+
+    function testAt95PercentTaxIdx8() public view {
+        // deltaS=5, effIdx=8 → penalty = 125*8/20 = 50, NOT < 50 → BEAR
+        assertFalse(optimizer.isBullMarket(_percentageStaked(95), _normalizedTaxRate(8)), "95% staked, taxIdx=8 should be bear");
+    }
+
+    function testAt95PercentTaxIdx9() public view {
+        // deltaS=5, effIdx=9 → penalty = 125*9/20 = 56 → BEAR
+        assertFalse(optimizer.isBullMarket(_percentageStaked(95), _normalizedTaxRate(9)), "95% staked, taxIdx=9 should be bear");
+    }
+
+    // ==================== 97% Staked ====================
+
+    function testAt97PercentLowTax() public view {
+        // deltaS=3, effIdx=0 → penalty = 27*0/20 = 0 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(97), _normalizedTaxRate(0)), "97% staked, lowest tax should be bull");
+    }
+
+    function testAt97PercentHighTax() public view {
+        // deltaS=3, effIdx=29 → penalty = 27*29/20 = 39 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(97), _normalizedTaxRate(29)), "97% staked, max tax should still be bull");
+    }
+
+    // ==================== 100% Staked ====================
+
+    function testAt100PercentAlwaysBull() public view {
+        // deltaS=0 → penalty = 0 → always BULL
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            assertTrue(optimizer.isBullMarket(1e18, _normalizedTaxRate(taxIdx)), "100% staked should always be bull");
+        }
+    }
+
+    // ==================== 96% Sweep ====================
+
+    function testAt96PercentSweep() public view {
+        // deltaS=4, cubic=64
+        // penalty = 64 * effIdx / 20
+        // Bull when penalty < 50, i.e., 64 * effIdx / 20 < 50 → effIdx < 15.625
+        // effIdx 0-15: bull (penalty 0..48). effIdx 16+: bear (penalty 51+)
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            bool result = optimizer.isBullMarket(_percentageStaked(96), _normalizedTaxRate(taxIdx));
+            // Compute expected: effIdx from the tax rate
+            uint256 effIdx = taxIdx;
+            if (taxIdx >= 14) {
+                effIdx = taxIdx + 1;
+                if (effIdx > 29) effIdx = 29;
+            }
+            uint256 penalty = 64 * effIdx / 20;
+            bool expectedBull = penalty < 50;
+            assertEq(result, expectedBull, string.concat("96% sweep mismatch at taxIdx=", vm.toString(taxIdx)));
+        }
+    }
+
+    // ==================== 94% Sweep ====================
+
+    function testAt94PercentSweep() public view {
+        // deltaS=6, cubic=216
+        // penalty = 216 * effIdx / 20
+        // Bull when penalty < 50, i.e., 216 * effIdx / 20 < 50 → effIdx < 4.629
+        // effIdx 0-4: bull. effIdx 5+: bear.
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            bool result = optimizer.isBullMarket(_percentageStaked(94), _normalizedTaxRate(taxIdx));
+            uint256 effIdx = taxIdx;
+            if (taxIdx >= 14) {
+                effIdx = taxIdx + 1;
+                if (effIdx > 29) effIdx = 29;
+            }
+            uint256 penalty = 216 * effIdx / 20;
+            bool expectedBull = penalty < 50;
+            assertEq(result, expectedBull, string.concat("94% sweep mismatch at taxIdx=", vm.toString(taxIdx)));
+        }
+    }
+
+    // ==================== Revert on Invalid Input ====================
+
+    function testRevertsAbove100Percent() public {
+        vm.expectRevert("Invalid percentage staked");
+        optimizer.isBullMarket(1e18 + 1, 0);
+    }
+
+    // ==================== 93% Staked ====================
+
+    function testAt93PercentSweep() public view {
+        // deltaS=7, cubic=343
+        // penalty = 343 * effIdx / 20
+        // Bull when penalty < 50, i.e., 343 * effIdx / 20 < 50 → effIdx < 2.915
+        // effIdx 0-2: bull. effIdx 3+: bear.
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            bool result = optimizer.isBullMarket(_percentageStaked(93), _normalizedTaxRate(taxIdx));
+            uint256 effIdx = taxIdx;
+            if (taxIdx >= 14) {
+                effIdx = taxIdx + 1;
+                if (effIdx > 29) effIdx = 29;
+            }
+            uint256 penalty = 343 * effIdx / 20;
+            bool expectedBull = penalty < 50;
+            assertEq(result, expectedBull, string.concat("93% sweep mismatch at taxIdx=", vm.toString(taxIdx)));
+        }
+    }
+
+    // ==================== 99% Staked ====================
+
+    function testAt99PercentAlwaysBull() public view {
+        // deltaS=1, cubic=1 → penalty = effIdx/20, always < 50 for effIdx <= 29
+        for (uint256 taxIdx = 0; taxIdx < 30; taxIdx++) {
+            assertTrue(optimizer.isBullMarket(_percentageStaked(99), _normalizedTaxRate(taxIdx)), "99% staked should always be bull");
+        }
+    }
+
+    // ==================== EffIdx Shift at Boundary (taxIdx 13 vs 14) ====================
+
+    function testEffIdxShiftAtBoundary() public view {
+        // At 96% staked, deltaS=4, cubic=64
+        // taxIdx=13: effIdx=13, penalty = 64*13/20 = 41 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(96), _normalizedTaxRate(13)), "taxIdx=13 should be bull at 96%");
+
+        // taxIdx=14: effIdx=15 (shift!), penalty = 64*15/20 = 48 < 50 → BULL
+        assertTrue(optimizer.isBullMarket(_percentageStaked(96), _normalizedTaxRate(14)), "taxIdx=14 should be bull at 96% (effIdx shift)");
+
+        // taxIdx=15: effIdx=16, penalty = 64*16/20 = 51 >= 50 → BEAR
+        assertFalse(optimizer.isBullMarket(_percentageStaked(96), _normalizedTaxRate(15)), "taxIdx=15 should be bear at 96%");
+    }
+
+    // ==================== Fuzz Tests ====================
+
+    function testFuzzBearBelow92(uint256 percentageStaked, uint256 taxIdx) public view {
+        percentageStaked = bound(percentageStaked, 0, 91e18 / 100);
+        taxIdx = bound(taxIdx, 0, 29);
+        assertFalse(optimizer.isBullMarket(percentageStaked, _normalizedTaxRate(taxIdx)), "Should always be bear below 92%");
+    }
+
+    function testFuzz100PercentAlwaysBull(uint256 taxIdx) public view {
+        taxIdx = bound(taxIdx, 0, 29);
+        assertTrue(optimizer.isBullMarket(1e18, _normalizedTaxRate(taxIdx)), "100% staked should always be bull");
+    }
+
+    function testFuzzNeverReverts(uint256 percentageStaked, uint256 averageTaxRate) public view {
+        percentageStaked = bound(percentageStaked, 0, 1e18);
+        averageTaxRate = bound(averageTaxRate, 0, 1e18);
+        // Should not revert
+        optimizer.isBullMarket(percentageStaked, averageTaxRate);
+    }
+}
diff --git a/onchain/test/abstracts/PriceOracle.t.sol b/onchain/test/abstracts/PriceOracle.t.sol
index e1ac035..301adc0 100644
--- a/onchain/test/abstracts/PriceOracle.t.sol
+++ b/onchain/test/abstracts/PriceOracle.t.sol
@@ -16,6 +16,10 @@ contract MockUniswapV3Pool {
     uint160[] public liquidityCumulatives;
     bool public shouldRevert;
 
+    // Fallback path support: separate tick cumulatives for the 60000s window
+    int56[] public fallbackTickCumulatives;
+    bool public revertOnlyPrimary; // true = revert on 300s, succeed on 60000s
+
     function setTickCumulatives(int56[] memory _tickCumulatives) external {
         tickCumulatives = _tickCumulatives;
     }
@@ -28,10 +32,25 @@ contract MockUniswapV3Pool {
         shouldRevert = _shouldRevert;
     }
 
-    function observe(uint32[] calldata) external view returns (int56[] memory, uint160[] memory) {
+    function setFallbackTickCumulatives(int56[] memory _fallbackTickCumulatives) external {
+        fallbackTickCumulatives = _fallbackTickCumulatives;
+    }
+
+    function setRevertOnlyPrimary(bool _revertOnlyPrimary) external {
+        revertOnlyPrimary = _revertOnlyPrimary;
+    }
+
+    function observe(uint32[] calldata secondsAgo) external view returns (int56[] memory, uint160[] memory) {
         if (shouldRevert) {
             revert("Mock oracle failure");
         }
+        // If revertOnlyPrimary is set, revert on 300s but succeed on 60000s
+        if (revertOnlyPrimary && secondsAgo[0] == 300) {
+            revert("Old observations not available");
+        }
+        if (revertOnlyPrimary && secondsAgo[0] == 60_000 && fallbackTickCumulatives.length > 0) {
+            return (fallbackTickCumulatives, liquidityCumulatives);
+        }
         return (tickCumulatives, liquidityCumulatives);
     }
 }
@@ -129,23 +148,53 @@ contract PriceOracleTest is Test {
         assertFalse(isStable, "Price should be unstable when outside deviation threshold");
     }
 
-    function testPriceStabilityOracleFailureFallback() public {
-        // Test fallback behavior when oracle fails
-        mockPool.setShouldRevert(true);
+    function testFallbackPathUsesCorrectDivisor() public {
+        // Primary observe (300s) reverts, fallback (60000s) succeeds
+        // The fallback window is 60000 seconds, so tickCumulativeDiff / 60000 = averageTick
+        int24 averageTick = 1000;
+        uint32 fallbackInterval = 60_000;
 
-        // Should not revert but should still return a boolean
-        // The actual implementation tries a longer timeframe on failure
-        int24 currentTick = 1000;
+        int56[] memory fallbackCumulatives = new int56[](2);
+        fallbackCumulatives[0] = 0;
+        fallbackCumulatives[1] = int56(averageTick) * int56(int32(fallbackInterval));
 
-        // This might fail or succeed depending on implementation details
-        // The key is that it doesn't cause the entire transaction to revert
-        try priceOracle.isPriceStable(currentTick) returns (bool result) {
-            // If it succeeds, that's fine
-            console.log("Oracle fallback succeeded, result:", result);
-        } catch {
-            // If it fails, that's also expected behavior for this test
-            console.log("Oracle fallback failed as expected");
-        }
+        uint160[] memory liquidityCumulatives = new uint160[](2);
+        liquidityCumulatives[0] = 1000;
+        liquidityCumulatives[1] = 1000;
+
+        mockPool.setRevertOnlyPrimary(true);
+        mockPool.setFallbackTickCumulatives(fallbackCumulatives);
+        mockPool.setLiquidityCumulatives(liquidityCumulatives);
+
+        // currentTick = 1020, averageTick = 1000 → within 50-tick deviation → stable
+        bool isStable = priceOracle.isPriceStable(1020);
+        assertTrue(isStable, "Fallback: price within deviation should be stable");
+
+        // currentTick = 1100, averageTick = 1000 → 100 ticks away → unstable
+        isStable = priceOracle.isPriceStable(1100);
+        assertFalse(isStable, "Fallback: price outside deviation should be unstable");
+    }
+
+    function testFallbackPathWithNegativeTick() public {
+        // Verify fallback works correctly with negative ticks
+        int24 averageTick = -500;
+        uint32 fallbackInterval = 60_000;
+
+        int56[] memory fallbackCumulatives = new int56[](2);
+        fallbackCumulatives[0] = 0;
+        fallbackCumulatives[1] = int56(averageTick) * int56(int32(fallbackInterval));
+
+        uint160[] memory liquidityCumulatives = new uint160[](2);
+        liquidityCumulatives[0] = 1000;
+        liquidityCumulatives[1] = 1000;
+
+        mockPool.setRevertOnlyPrimary(true);
+        mockPool.setFallbackTickCumulatives(fallbackCumulatives);
+        mockPool.setLiquidityCumulatives(liquidityCumulatives);
+
+        // currentTick = -480, averageTick = -500 → diff = 20 → stable
+        bool isStable = priceOracle.isPriceStable(-480);
+        assertTrue(isStable, "Fallback with negative tick: within deviation should be stable");
     }
 
     function testPriceStabilityExactBoundary() public {
diff --git a/onchain/test/abstracts/ThreePositionStrategy.t.sol b/onchain/test/abstracts/ThreePositionStrategy.t.sol
index a00c7e2..884b289 100644
--- a/onchain/test/abstracts/ThreePositionStrategy.t.sol
+++ b/onchain/test/abstracts/ThreePositionStrategy.t.sol
@@ -264,42 +264,47 @@ contract ThreePositionStrategyTest is TestConstants {
         assertNotEq(centerTick, CURRENT_TICK, "Floor should not be positioned at current tick when VWAP available");
     }
 
-    function testFloorPositionEthScarcity() public {
+    function testFloorPositionScarcityDominates() public {
         ThreePositionStrategy.PositionParams memory params = getDefaultParams();
 
-        // Set up scenario where ETH is insufficient for VWAP price
+        // Set up scenario where ETH is insufficient → scarcity tick dominates
         uint256 vwapX96 = 79_228_162_514_264_337_593_543_950_336 * 10; // High VWAP price
         strategy.setVWAP(vwapX96, 1000 ether);
 
-        uint256 smallEthBalance = 1 ether; // Insufficient ETH
+        uint256 smallEthBalance = 1 ether; // Very low ETH → scarcity tick far away
         uint256 pulledHarb = 1000 ether;
         uint256 discoveryAmount = 500 ether;
 
-        // Should emit EthScarcity event (check event type, not exact values)
-        vm.expectEmit(true, false, false, false);
-        emit ThreePositionStrategy.EthScarcity(CURRENT_TICK, 0, 0, 0, 0);
-
+        // Should not revert — floor placed using max(scarcity, mirror, clamp)
         strategy.setFloorPosition(CURRENT_TICK, smallEthBalance, pulledHarb, discoveryAmount, params);
+
+        // Floor should be minted (position exists)
+        MockThreePositionStrategy.MintedPosition memory pos = strategy.getMintedPosition(0);
+        assertTrue(pos.liquidity > 0, "Floor should have liquidity");
     }
 
-    function testFloorPositionEthAbundance() public {
+    function testFloorPositionMirrorDominates() public {
         ThreePositionStrategy.PositionParams memory params = getDefaultParams();
 
-        // Set up scenario where ETH is sufficient for VWAP price
+        // Set up scenario where VWAP is far from current → mirror tick dominates
         uint256 baseVwap = 79_228_162_514_264_337_593_543_950_336; // 1.0 in X96 format
-        uint256 vwapX96 = baseVwap / 100_000; // Very low VWAP price to ensure abundance
+        uint256 vwapX96 = baseVwap / 100_000; // Very low VWAP price → far from current
         strategy.setVWAP(vwapX96, 1000 ether);
 
-        uint256 largeEthBalance = 100_000 ether; // Very large ETH balance
+        uint256 largeEthBalance = 100_000 ether; // Lots of ETH
         uint256 pulledHarb = 1000 ether;
         uint256 discoveryAmount = 500 ether;
 
-        // Should emit EthAbundance event (check event type, not exact values)
-        // The exact VWAP and vwapTick values are calculated, so we just check the event type
-        vm.expectEmit(true, false, false, false);
-        emit ThreePositionStrategy.EthAbundance(CURRENT_TICK, 0, 0, 0, 0);
-
         strategy.setFloorPosition(CURRENT_TICK, largeEthBalance, pulledHarb, discoveryAmount, params);
+
+        MockThreePositionStrategy.MintedPosition memory pos = strategy.getMintedPosition(0);
+        assertTrue(pos.liquidity > 0, "Floor should have liquidity");
+
+        // Floor should be further than just anchorSpacing (mirror should push it)
+        int24 anchorSpacing = 200 + (34 * 50 * 200 / 100); // 3600
+        int24 floorCenter = (pos.tickLower + pos.tickUpper) / 2;
+        // Mirror should push floor significantly beyond clamp minimum
+        assertTrue(floorCenter > CURRENT_TICK + anchorSpacing + 200, "Mirror should push floor beyond clamp minimum");
     }
 
     function testFloorPositionNoVWAP() public {
@@ -316,16 +321,34 @@ contract ThreePositionStrategyTest is TestConstants {
 
         MockThreePositionStrategy.MintedPosition memory pos = strategy.getMintedPosition(0);
 
-        // Without VWAP, should default to current tick but adjusted for anchor spacing
+        // Without VWAP, mirror = current tick, so floor uses max(scarcity, clamp)
+        // With these balances, scarcity tick should dominate (low ETH relative to supply)
         int24 centerTick = (pos.tickLower + pos.tickUpper) / 2;
-        // Expected spacing: TICK_SPACING + (34 * anchorWidth * TICK_SPACING / 100) = 200 + (34 * 50 * 200 / 100) = 3600
-        int24 expectedSpacing = 200 + (34 * 50 * 200 / 100);
-        assertApproxEqAbs(
-            uint256(int256(centerTick)),
-            uint256(int256(CURRENT_TICK + expectedSpacing)),
-            200,
-            "Floor should be positioned away from current tick to avoid anchor overlap"
-        );
+        // Floor should be above current tick (on KRK-cheap side)
+        assertTrue(centerTick > CURRENT_TICK, "Floor should be on KRK-cheap side of current tick");
+        assertTrue(pos.liquidity > 0, "Floor should have liquidity");
+    }
+
+    function testFloorPositionNoVWAPClampOrScarcity() public {
+        ThreePositionStrategy.PositionParams memory params = getDefaultParams();
+
+        // No VWAP data, large ETH balance, small supply
+        strategy.setVWAP(0, 0);
+
+        uint256 floorEthBalance = 100_000 ether; // Very large
+        uint256 pulledHarb = 100 ether; // Small supply
+        uint256 discoveryAmount = 50 ether;
+
+        strategy.setFloorPosition(CURRENT_TICK, floorEthBalance, pulledHarb, discoveryAmount, params);
+
+        MockThreePositionStrategy.MintedPosition memory pos = strategy.getMintedPosition(0);
+
+        // With no VWAP: mirror = current. Floor uses max(scarcity, clamp).
+        // The scarcity formula with small supply and large ETH may still push floor
+        // significantly beyond the clamp minimum. Just verify floor is on correct side.
+        int24 centerTick = (pos.tickLower + pos.tickUpper) / 2;
+        int24 minSpacing = 200 + (34 * 50 * 200 / 100); // 3600
+        assertTrue(centerTick >= CURRENT_TICK + minSpacing, "Floor should be positioned away from current tick to avoid anchor overlap");
     }
 
     function testFloorPositionOutstandingSupplyCalculation() public {
diff --git a/onchain/test/helpers/TestBase.sol b/onchain/test/helpers/TestBase.sol
index 0a2d50d..574985f 100644
--- a/onchain/test/helpers/TestBase.sol
+++ b/onchain/test/helpers/TestBase.sol
@@ -147,7 +147,7 @@ contract TestEnvironment is TestConstants {
         bool setupComplete = false;
         uint256 retryCount = 0;
 
-        while (!setupComplete && retryCount < 5) {
+        while (!setupComplete && retryCount < 20) {
             // Clean slate if retrying
             if (retryCount > 0) {
                 // Deploy a dummy contract to shift addresses
@@ -195,7 +195,6 @@ contract TestEnvironment is TestConstants {
      */
     function _configurePermissions() internal {
         harberg.setStakingPool(address(stake));
-        vm.prank(feeDestination);
         harberg.setLiquidityManager(address(lm));
         vm.deal(address(lm), INITIAL_LM_ETH_BALANCE);
     }
@@ -313,5 +312,4 @@ contract TestEnvironment is TestConstants {
 
         return (factory, pool, weth, harberg, stake, lm, optimizer, token0isWeth);
     }
-
 }
diff --git a/scripts/bootstrap-common.sh b/scripts/bootstrap-common.sh
index a036658..22ac62b 100755
--- a/scripts/bootstrap-common.sh
+++ b/scripts/bootstrap-common.sh
@@ -68,6 +68,7 @@ extract_addresses() {
   LIQUIDITY_MANAGER="$(jq -r '.transactions[] | select(.contractName=="LiquidityManager") | .contractAddress' "$run_file" | head -n1)"
   KRAIKEN="$(jq -r '.transactions[] | select(.contractName=="Kraiken") | .contractAddress' "$run_file" | head -n1)"
   STAKE="$(jq -r '.transactions[] | select(.contractName=="Stake") | .contractAddress' "$run_file" | head -n1)"
+  OPTIMIZER_PROXY="$(jq -r '.transactions[] | select(.contractName=="ERC1967Proxy") | .contractAddress' "$run_file" | head -n1)"
   DEPLOY_BLOCK="$(jq -r '.receipts[0].blockNumber' "$run_file" | xargs printf "%d")"
   if [[ -z "$LIQUIDITY_MANAGER" || "$LIQUIDITY_MANAGER" == "null" ]]; then
     bootstrap_log "LiquidityManager address missing"
@@ -150,7 +151,8 @@ write_deployments_json() {
   "contracts": {
     "Kraiken": "$KRAIKEN",
     "Stake": "$STAKE",
-    "LiquidityManager": "$LIQUIDITY_MANAGER"
+    "LiquidityManager": "$LIQUIDITY_MANAGER",
+    "OptimizerProxy": "$OPTIMIZER_PROXY"
   }
 }
 EODEPLOYMENTS
diff --git a/services/ponder/abis/Kraiken.json b/services/ponder/abis/Kraiken.json
index 33dae12..5df7df5 100644
--- a/services/ponder/abis/Kraiken.json
+++ b/services/ponder/abis/Kraiken.json
@@ -1 +1 @@
-[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressAlreadySet","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[],"name":"ZeroAddressInSetter","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"outstandingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"peripheryContracts","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"previousTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityManager_","type":"address"}],"name":"setLiquidityManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ts","type":"uint256"}],"name":"setPreviousTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakingPool_","type":"address"}],"name":"setStakingPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
\ No newline at end of file
+{"abi":[{"type":"constructor","inputs":[{"name":"name_","type":"string","internalType":"string"},{"name":"symbol_","type":"string","internalType":"string"}],"stateMutability":"nonpayable"},{"type":"function","name":"DOMAIN_SEPARATOR","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"type":"function","name":"VERSION","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"allowance","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"approve","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"type":"function","name":"balanceOf","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"burn","inputs":[{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"decimals","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"type":"function","name":"decreaseAllowance","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"type":"function","name":"eip712Domain","inputs":[],"outputs":[{"name":"fields","type":"bytes1","internalType":"bytes1"},{"name":"name","type":"string","internalType":"string"},{"name":"version","type":"string","internalType":"string"},{"name":"chainId","type":"uint256","internalType":"uint256"},{"name":"verifyingContract","type":"address","internalType":"address"},{"name":"salt","type":"bytes32","internalType":"bytes32"},{"name":"extensions","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"type":"function","name":"increaseAllowance","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"type":"function","name":"minStake","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"mint","inputs":[{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"name","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"function","name":"nonces","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"outstandingSupply","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"peripheryContracts","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"permit","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"previousTotalSupply","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"setLiquidityManager","inputs":[{"name":"liquidityManager_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"setPreviousTotalSupply","inputs":[{"name":"_ts","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"setStakingPool","inputs":[{"name":"stakingPool_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"symbol","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"transfer","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"type":"function","name":"transferFrom","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"type":"event","name":"Approval","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"EIP712DomainChanged","inputs":[],"anonymous":false},{"type":"event","name":"Transfer","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"error","name":"AddressAlreadySet","inputs":[]},{"type":"error","name":"InvalidShortString","inputs":[]},{"type":"error","name":"StringTooLong","inputs":[{"name":"str","type":"string","internalType":"string"}]},{"type":"error","name":"ZeroAddressInSetter","inputs":[]}],"bytecode":{"object":"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","sourceMap":"818:5693:80:-:0;;;2183:100;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3178:431:48;;;;;;;;;;;;-1:-1:-1;;;3178:431:48;;;;2273:5:80;;;;;2252:7;2046:5:35;:13;2273:5:80;2046::35;:13;:::i;:::-;-1:-1:-1;2069:7:35;:17;2079:7;2069;:17;:::i;:::-;-1:-1:-1;3251:45:48;;-1:-1:-1;3251:4:48;;-1:-1:-1;3282:13:48;3251:30;:45::i;:::-;3243:53;;3317:51;:7;3351:16;3317:33;:51::i;:::-;3306:62;;3392:22;;;;;;;;;;3378:36;;3441:25;;;;;;3424:42;;3494:13;3477:30;;3542:23;4077:11;;4090:14;;4054:81;;;1929:95;4054:81;;;4204:25:114;4245:18;;;4238:34;;;;4288:18;;;4281:34;4106:13:48;4331:18:114;;;4324:34;4129:4:48;4374:19:114;;;4367:61;4018:7:48;;4176:19:114;;4054:81:48;;;;;;;;;;;;4044:92;;;;;;4037:99;;3963:180;;3542:23;3517:48;;-1:-1:-1;;3597:4:48;3575:27;;-1:-1:-1;818:5693:80;;-1:-1:-1;;818:5693:80;2895:341:44;2991:11;3040:2;3024:5;3018:19;:24;3014:216;;;3065:20;3079:5;3065:13;:20::i;:::-;3058:27;;;;3014:216;3142:5;3116:46;3157:5;3142;3116:46;:::i;:::-;-1:-1:-1;1371:66:44;;-1:-1:-1;3014:216:44;2895:341;;;;:::o;1689:286::-;1754:11;1777:17;1803:3;1777:30;;1835:2;1821:4;:11;:16;1817:72;;;1874:3;1860:18;;-1:-1:-1;;;1860:18:44;;;;;;;;:::i;:::-;;;;;;;;1817:72;1955:11;;1938:13;1955:4;1938:13;:::i;:::-;1930:36;;1689:286;-1:-1:-1;;;1689:286:44:o;14:127:114:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:723;200:5;253:3;246:4;238:6;234:17;230:27;220:55;;271:1;268;261:12;220:55;298:13;;-1:-1:-1;;;;;323:30:114;;320:56;;;356:18;;:::i;:::-;405:2;399:9;497:2;459:17;;-1:-1:-1;;455:31:114;;;488:2;451:40;447:54;435:67;;-1:-1:-1;;;;;517:34:114;;553:22;;;514:62;511:88;;;579:18;;:::i;:::-;615:2;608:22;639;;;680:19;;;701:4;676:30;673:39;-1:-1:-1;670:59:114;;;725:1;722;715:12;670:59;782:6;775:4;767:6;763:17;756:4;748:6;744:17;738:51;837:1;809:19;;;830:4;805:30;798:41;;;;813:6;146:723;-1:-1:-1;;;146:723:114:o;874:557::-;973:6;981;1034:2;1022:9;1013:7;1009:23;1005:32;1002:52;;;1050:1;1047;1040:12;1002:52;1077:16;;-1:-1:-1;;;;;1105:30:114;;1102:50;;;1148:1;1145;1138:12;1102:50;1171:61;1224:7;1215:6;1204:9;1200:22;1171:61;:::i;:::-;1278:2;1263:18;;1257:25;1161:71;;-1:-1:-1;1257:25:114;-1:-1:-1;;;;;;1294:32:114;;1291:52;;;1339:1;1336;1329:12;1291:52;1362:63;1417:7;1406:8;1395:9;1391:24;1362:63;:::i;:::-;1352:73;;;874:557;;;;;:::o;1436:380::-;1515:1;1511:12;;;;1558;;;1579:61;;1633:4;1625:6;1621:17;1611:27;;1579:61;1686:2;1678:6;1675:14;1655:18;1652:38;1649:161;;1732:10;1727:3;1723:20;1720:1;1713:31;1767:4;1764:1;1757:15;1795:4;1792:1;1785:15;1649:161;;1436:380;;;:::o;1947:518::-;2049:2;2044:3;2041:11;2038:421;;;2085:5;2082:1;2075:16;2129:4;2126:1;2116:18;2199:2;2187:10;2183:19;2180:1;2176:27;2170:4;2166:38;2235:4;2223:10;2220:20;2217:47;;;-1:-1:-1;2258:4:114;2217:47;2313:2;2308:3;2304:12;2301:1;2297:20;2291:4;2287:31;2277:41;;2368:81;2386:2;2379:5;2376:13;2368:81;;;2445:1;2431:16;;2412:1;2401:13;2368:81;;;2372:3;;2038:421;1947:518;;;:::o;2641:1299::-;2761:10;;-1:-1:-1;;;;;2783:30:114;;2780:56;;;2816:18;;:::i;:::-;2845:97;2935:6;2895:38;2927:4;2921:11;2895:38;:::i;:::-;2889:4;2845:97;:::i;:::-;2991:4;3022:2;3011:14;;3039:1;3034:649;;;;3727:1;3744:6;3741:89;;;-1:-1:-1;3796:19:114;;;3790:26;3741:89;-1:-1:-1;;2598:1:114;2594:11;;;2590:24;2586:29;2576:40;2622:1;2618:11;;;2573:57;3843:81;;3004:930;;3034:649;1894:1;1887:14;;;1931:4;1918:18;;-1:-1:-1;;3070:20:114;;;3188:222;3202:7;3199:1;3196:14;3188:222;;;3284:19;;;3278:26;3263:42;;3391:4;3376:20;;;;3344:1;3332:14;;;;3218:12;3188:222;;;3192:3;3438:6;3429:7;3426:19;3423:201;;;3499:19;;;3493:26;-1:-1:-1;;3582:1:114;3578:14;;;3594:3;3574:24;3570:37;3566:42;3551:58;3536:74;;3423:201;-1:-1:-1;;;;3670:1:114;3654:14;;;3650:22;3637:36;;-1:-1:-1;2641:1299:114:o;4439:418::-;4588:2;4577:9;4570:21;4551:4;4620:6;4614:13;4663:6;4658:2;4647:9;4643:18;4636:34;4722:6;4717:2;4709:6;4705:15;4700:2;4689:9;4685:18;4679:50;4778:1;4773:2;4764:6;4753:9;4749:22;4745:31;4738:42;4848:2;4841;4837:7;4832:2;4824:6;4820:15;4816:29;4805:9;4801:45;4797:54;4789:62;;;4439:418;;;;:::o;4862:297::-;4980:12;;5027:4;5016:16;;;5010:23;;4980:12;5045:16;;5042:111;;;-1:-1:-1;;5119:4:114;5115:17;;;;5112:1;5108:25;5104:38;5093:50;;4862:297;-1:-1:-1;4862:297:114:o;:::-;818:5693:80;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"818:5693:80:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2158:98:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4444:197;;;;;;:::i;:::-;;:::i;:::-;;;1181:14:114;;1174:22;1156:41;;1144:2;1129:18;4444:197:35;1016:187:114;3255:106:35;3342:12;;3255:106;;;1354:25:114;;;1342:2;1327:18;3255:106:35;1208:177:114;5203:256:35;;;;;;:::i;:::-;;:::i;3288:235:80:-;;;;;;:::i;:::-;;:::i;:::-;;3104:91:35;;;3186:2;2102:36:114;;2090:2;2075:18;3104:91:35;1960:184:114;2836:113:37;;;:::i;3981:116:80:-;;;:::i;5854:234:35:-;;;;;;:::i;:::-;;:::i;2663:265:80:-;;;;;;:::i;:::-;;:::i;5478:496::-;;;;;;:::i;:::-;;:::i;3419:125:35:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3519:18:35;3493:7;3519:18;;;;;;;;;;;;3419:125;2603:126:37;;;;;;:::i;:::-;;:::i;1703:34:80:-;;;;;;5021:633:48;;;:::i;:::-;;;;;;;;;;;;;:::i;2369:102:35:-;;;:::i;6092:117:80:-;;;;;;:::i;:::-;;:::i;4453:598::-;;;;;;:::i;:::-;;:::i;6575:427:35:-;;;;;;:::i;:::-;;:::i;3740:189::-;;;;;;:::i;:::-;;:::i;3714:126:80:-;3803:16;;3821:11;;3714:126;;;-1:-1:-1;;;;;3803:16:80;;;3979:51:114;;3821:11:80;;;;4061:2:114;4046:18;;4039:60;3952:18;3714:126:80;3805:300:114;6383:126:80;;;:::i;1923:626:37:-;;;;;;:::i;:::-;;:::i;3987:149:35:-;;;;;;:::i;:::-;;:::i;1293:35:80:-;;1327:1;1293:35;;2158:98:35;2212:13;2244:5;2237:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2158:98;:::o;4444:197::-;4527:4;734:10:42;4581:32:35;734:10:42;4597:7:35;4606:6;4581:8;:32::i;:::-;4630:4;4623:11;;;4444:197;;;;;:::o;5203:256::-;5300:4;734:10:42;5356:38:35;5372:4;734:10:42;5387:6:35;5356:15;:38::i;:::-;5404:27;5414:4;5420:2;5424:6;5404:9;:27::i;:::-;-1:-1:-1;5448:4:35;;5203:256;-1:-1:-1;;;;5203:256:35:o;3288:235:80:-;-1:-1:-1;;;;;3357:26:80;;3365:1;3357:26;3353:60;;3392:21;;-1:-1:-1;;;3392:21:80;;;;;;;;;;;3353:60;3427:11;;-1:-1:-1;;;;;3427:11:80;:25;3423:57;;3461:19;;-1:-1:-1;;;3461:19:80;;;;;;;;;;;3423:57;3490:11;:26;;-1:-1:-1;;;;;;3490:26:80;-1:-1:-1;;;;;3490:26:80;;;;;;;;;;3288:235::o;2836:113:37:-;2896:7;2922:20;:18;:20::i;:::-;2915:27;;2836:113;:::o;3981:116:80:-;4024:7;1492:4;4050:19;;:40;;;;:::i;5854:234:35:-;5942:4;734:10:42;5996:64:35;734:10:42;6012:7:35;6049:10;6021:25;734:10:42;6012:7:35;6021:9;:25::i;:::-;:38;;;;:::i;:::-;5996:8;:64::i;2663:265:80:-;-1:-1:-1;;;;;2742:31:80;;2750:1;2742:31;2738:65;;2782:21;;-1:-1:-1;;;2782:21:80;;;;;;;;;;;2738:65;2817:16;;-1:-1:-1;;;;;2817:16:80;:30;2813:62;;2856:19;;-1:-1:-1;;;2856:19:80;;;;;;;;;;;2813:62;2885:16;:36;;-1:-1:-1;;;;;;2885:36:80;-1:-1:-1;;;;;2885:36:80;;;;;;;;;;2663:265::o;5478:496::-;1962:16;;-1:-1:-1;;;;;1962:16:80;1940:10;:39;1932:74;;;;-1:-1:-1;;;1932:74:80;;;;;;;:::i;:::-;;;;;;;;;5553:11;;5549:419:::1;;5678:11;::::0;-1:-1:-1;;;;;5678:11:80::1;5639:26;3519:18:35::0;;;;;;;;;;;5708:22:80;;5704:199:::1;;5750:19;5820:18;5804:13;3342:12:35::0;;;3255:106;5804:13:80::1;:34;;;;:::i;:::-;5772:28;5793:7:::0;5772:18;:28:::1;:::i;:::-;:67;;;;:::i;:::-;5863:11;::::0;5750:89;;-1:-1:-1;5857:31:80::1;::::0;-1:-1:-1;;;;;5863:11:80::1;5750:89:::0;5857:5:::1;:31::i;:::-;5732:171;5704:199;5930:16;::::0;5916:41:::1;::::0;-1:-1:-1;;;;;5930:16:80::1;5949:7:::0;5916:5:::1;:41::i;:::-;5566:402;5549:419;5478:496:::0;:::o;2603:126:37:-;-1:-1:-1;;;;;2698:14:37;;2672:7;2698:14;;;:7;:14;;;;;918::43;2698:24:37;827:112:43;5021:633:48;5136:13;5163:18;;5136:13;;;5163:18;5427:41;:5;5454:13;5427:26;:41::i;:::-;5482:47;:8;5512:16;5482:29;:47::i;:::-;5621:16;;;5605:1;5621:16;;;;;;;;;-1:-1:-1;;;5376:271:48;;;-1:-1:-1;5376:271:48;;-1:-1:-1;5543:13:48;;-1:-1:-1;5578:4:48;;-1:-1:-1;5605:1:48;-1:-1:-1;5621:16:48;-1:-1:-1;5376:271:48;-1:-1:-1;5021:633:48:o;2369:102:35:-;2425:13;2457:7;2450:14;;;;;:::i;6092:117:80:-;1962:16;;-1:-1:-1;;;;;1962:16:80;1940:10;:39;1932:74;;;;-1:-1:-1;;;1932:74:80;;;;;;;:::i;:::-;6177:19:::1;:25:::0;6092:117::o;4453:598::-;1962:16;;-1:-1:-1;;;;;1962:16:80;1940:10;:39;1932:74;;;;-1:-1:-1;;;1932:74:80;;;;;;;:::i;:::-;4528:11;;4524:422:::1;;4662:11;::::0;-1:-1:-1;;;;;4662:11:80::1;4623:26;3519:18:35::0;;;;;;;;;;;4692:22:80;;4688:193:::1;;4734:16;4801:18;4785:13;3342:12:35::0;;;3255:106;4785:13:80::1;:34;;;;:::i;:::-;4753:28;4774:7:::0;4753:18;:28:::1;:::i;:::-;:67;;;;:::i;:::-;4844:11;::::0;4734:86;;-1:-1:-1;4838:28:80::1;::::0;-1:-1:-1;;;;;4844:11:80::1;4734:86:::0;4838:5:::1;:28::i;:::-;4716:165;4688:193;4908:16;::::0;4894:41:::1;::::0;-1:-1:-1;;;;;4908:16:80::1;4927:7:::0;4894:5:::1;:41::i;:::-;4541:405;4524:422;4959:19;;4982:1;4959:24:::0;4955:90:::1;;3342:12:35::0;;4999:19:80::1;:35:::0;4453:598;:::o;6575:427:35:-;6668:4;734:10:42;6668:4:35;6749:25;734:10:42;6766:7:35;6749:9;:25::i;:::-;6722:52;;6812:15;6792:16;:35;;6784:85;;;;-1:-1:-1;;;6784:85:35;;7143:2:114;6784:85:35;;;7125:21:114;7182:2;7162:18;;;7155:30;7221:34;7201:18;;;7194:62;-1:-1:-1;;;7272:18:114;;;7265:35;7317:19;;6784:85:35;6941:401:114;6784:85:35;6903:60;6912:5;6919:7;6947:15;6928:16;:34;6903:8;:60::i;3740:189::-;3819:4;734:10:42;3873:28:35;734:10:42;3890:2:35;3894:6;3873:9;:28::i;6383:126:80:-;6485:16;;-1:-1:-1;;;;;6485:16:80;6433:7;3519:18:35;;;;;;;;;;;3342:12;;6459:43:80;;;;:::i;1923:626:37:-;2158:8;2139:15;:27;;2131:69;;;;-1:-1:-1;;;2131:69:37;;7549:2:114;2131:69:37;;;7531:21:114;7588:2;7568:18;;;7561:30;7627:31;7607:18;;;7600:59;7676:18;;2131:69:37;7347:353:114;2131:69:37;2211:18;1125:95;2271:5;2278:7;2287:5;2294:16;2304:5;2294:9;:16::i;:::-;2242:79;;;;;;7992:25:114;;;;-1:-1:-1;;;;;8053:32:114;;;8033:18;;;8026:60;8122:32;;;;8102:18;;;8095:60;8171:18;;;8164:34;8214:19;;;8207:35;8258:19;;;8251:35;;;7964:19;;2242:79:37;;;;;;;;;;;;2232:90;;;;;;2211:111;;2333:12;2348:28;2365:10;2348:16;:28::i;:::-;2333:43;;2387:14;2404:28;2418:4;2424:1;2427;2430;2404:13;:28::i;:::-;2387:45;;2460:5;-1:-1:-1;;;;;2450:15:37;:6;-1:-1:-1;;;;;2450:15:37;;2442:58;;;;-1:-1:-1;;;2442:58:37;;8499:2:114;2442:58:37;;;8481:21:114;8538:2;8518:18;;;8511:30;8577:32;8557:18;;;8550:60;8627:18;;2442:58:37;8297:354:114;2442:58:37;2511:31;2520:5;2527:7;2536:5;2511:8;:31::i;:::-;2121:428;;;1923:626;;;;;;;:::o;3987:149:35:-;-1:-1:-1;;;;;4102:18:35;;;4076:7;4102:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3987:149::o;10457:340::-;-1:-1:-1;;;;;10558:19:35;;10550:68;;;;-1:-1:-1;;;10550:68:35;;8858:2:114;10550:68:35;;;8840:21:114;8897:2;8877:18;;;8870:30;8936:34;8916:18;;;8909:62;-1:-1:-1;;;8987:18:114;;;8980:34;9031:19;;10550:68:35;8656:400:114;10550:68:35;-1:-1:-1;;;;;10636:21:35;;10628:68;;;;-1:-1:-1;;;10628:68:35;;9263:2:114;10628:68:35;;;9245:21:114;9302:2;9282:18;;;9275:30;9341:34;9321:18;;;9314:62;-1:-1:-1;;;9392:18:114;;;9385:32;9434:19;;10628:68:35;9061:398:114;10628:68:35;-1:-1:-1;;;;;10707:18:35;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10758:32;;1354:25:114;;;10758:32:35;;1327:18:114;10758:32:35;;;;;;;;10457:340;;;:::o;11078:411::-;11178:24;11205:25;11215:5;11222:7;11205:9;:25::i;:::-;11178:52;;-1:-1:-1;;11244:16:35;:37;11240:243;;11325:6;11305:16;:26;;11297:68;;;;-1:-1:-1;;;11297:68:35;;9666:2:114;11297:68:35;;;9648:21:114;9705:2;9685:18;;;9678:30;9744:31;9724:18;;;9717:59;9793:18;;11297:68:35;9464:353:114;11297:68:35;11407:51;11416:5;11423:7;11451:6;11432:16;:25;11407:8;:51::i;:::-;11168:321;11078:411;;;:::o;7456:788::-;-1:-1:-1;;;;;7552:18:35;;7544:68;;;;-1:-1:-1;;;7544:68:35;;10024:2:114;7544:68:35;;;10006:21:114;10063:2;10043:18;;;10036:30;10102:34;10082:18;;;10075:62;-1:-1:-1;;;10153:18:114;;;10146:35;10198:19;;7544:68:35;9822:401:114;7544:68:35;-1:-1:-1;;;;;7630:16:35;;7622:64;;;;-1:-1:-1;;;7622:64:35;;10430:2:114;7622:64:35;;;10412:21:114;10469:2;10449:18;;;10442:30;10508:34;10488:18;;;10481:62;-1:-1:-1;;;10559:18:114;;;10552:33;10602:19;;7622:64:35;10228:399:114;7622:64:35;-1:-1:-1;;;;;7768:15:35;;7746:19;7768:15;;;;;;;;;;;7801:21;;;;7793:72;;;;-1:-1:-1;;;7793:72:35;;10834:2:114;7793:72:35;;;10816:21:114;10873:2;10853:18;;;10846:30;10912:34;10892:18;;;10885:62;-1:-1:-1;;;10963:18:114;;;10956:36;11009:19;;7793:72:35;10632:402:114;7793:72:35;-1:-1:-1;;;;;7899:15:35;;;:9;:15;;;;;;;;;;;7917:20;;;7899:38;;8114:13;;;;;;;;;;:23;;;;;;8163:26;;1354:25:114;;;8114:13:35;;8163:26;;1327:18:114;8163:26:35;;;;;;;8200:37;9375:659;3695:262:48;3748:7;3779:4;-1:-1:-1;;;;;3788:11:48;3771:28;;:63;;;;;3820:14;3803:13;:31;3771:63;3767:184;;;-1:-1:-1;3857:22:48;;3695:262::o;3767:184::-;3917:23;4054:81;;;1929:95;4054:81;;;12463:25:114;4077:11:48;12504:18:114;;;12497:34;;;;4090:14:48;12547:18:114;;;12540:34;4106:13:48;12590:18:114;;;12583:34;4129:4:48;12633:19:114;;;12626:61;4018:7:48;;12435:19:114;;4054:81:48;;;;;;;;;;;;4044:92;;;;;;4037:99;;3963:180;;9375:659:35;-1:-1:-1;;;;;9458:21:35;;9450:67;;;;-1:-1:-1;;;9450:67:35;;11241:2:114;9450:67:35;;;11223:21:114;11280:2;11260:18;;;11253:30;11319:34;11299:18;;;11292:62;-1:-1:-1;;;11370:18:114;;;11363:31;11411:19;;9450:67:35;11039:397:114;9450:67:35;-1:-1:-1;;;;;9613:18:35;;9588:22;9613:18;;;;;;;;;;;9649:24;;;;9641:71;;;;-1:-1:-1;;;9641:71:35;;11643:2:114;9641:71:35;;;11625:21:114;11682:2;11662:18;;;11655:30;11721:34;11701:18;;;11694:62;-1:-1:-1;;;11772:18:114;;;11765:32;11814:19;;9641:71:35;11441:398:114;9641:71:35;-1:-1:-1;;;;;9746:18:35;;:9;:18;;;;;;;;;;;9767:23;;;9746:44;;9883:12;:22;;;;;;;9931:37;1354:25:114;;;9746:9:35;;:18;9931:37;;1327:18:114;9931:37:35;1208:177:114;3367:268:44;3461:13;1371:66;3490:47;;3486:143;;3560:15;3569:5;3560:8;:15::i;:::-;3553:22;;;;3486:143;3613:5;3606:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8520:535:35;-1:-1:-1;;;;;8603:21:35;;8595:65;;;;-1:-1:-1;;;8595:65:35;;12046:2:114;8595:65:35;;;12028:21:114;12085:2;12065:18;;;12058:30;12124:33;12104:18;;;12097:61;12175:18;;8595:65:35;11844:355:114;8595:65:35;8747:6;8731:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;8899:18:35;;:9;:18;;;;;;;;;;;:28;;;;;;8952:37;1354:25:114;;;8952:37:35;;1327:18:114;8952:37:35;;;;;;;9000:48;9375:659;3080:203:37;-1:-1:-1;;;;;3200:14:37;;3140:15;3200:14;;;:7;:14;;;;;918::43;;1050:1;1032:19;;;;918:14;3259:17:37;3157:126;3080:203;;;:::o;4768:165:48:-;4845:7;4871:55;4893:20;:18;:20::i;:::-;4915:10;8536:4:47;8530:11;-1:-1:-1;;;8554:23:47;;8606:4;8597:14;;8590:39;;;;8658:4;8649:14;;8642:34;8712:4;8697:20;;;8336:397;6598:232;6683:7;6703:17;6722:18;6744:25;6755:4;6761:1;6764;6767;6744:10;:25::i;:::-;6702:67;;;;6779:18;6791:5;6779:11;:18::i;:::-;-1:-1:-1;6814:9:47;6598:232;-1:-1:-1;;;;;6598:232:47:o;2059:405:44:-;2118:13;2143:11;2157:16;2168:4;2157:10;:16::i;:::-;2281:14;;;2292:2;2281:14;;;;;;;;;2143:30;;-1:-1:-1;2261:17:44;;2281:14;;;;;;;;;-1:-1:-1;;;2371:16:44;;;-1:-1:-1;2416:4:44;2407:14;;2400:28;;;;-1:-1:-1;2371:16:44;2059:405::o;5009:1456:47:-;5097:7;;6021:66;6008:79;;6004:161;;;-1:-1:-1;6119:1:47;;-1:-1:-1;6123:30:47;6103:51;;6004:161;6276:24;;;6259:14;6276:24;;;;;;;;;12925:25:114;;;12998:4;12986:17;;12966:18;;;12959:45;;;;13020:18;;;13013:34;;;13063:18;;;13056:34;;;6276:24:47;;12897:19:114;;6276:24:47;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6276:24:47;;-1:-1:-1;;6276:24:47;;;-1:-1:-1;;;;;;;6314:20:47;;6310:101;;6366:1;6370:29;6350:50;;;;;;;6310:101;6429:6;-1:-1:-1;6437:20:47;;-1:-1:-1;5009:1456:47;;;;;;;;:::o;570:511::-;647:20;638:5;:29;;;;;;;;:::i;:::-;;634:441;;570:511;:::o;634:441::-;743:29;734:5;:38;;;;;;;;:::i;:::-;;730:345;;788:34;;-1:-1:-1;;;788:34:47;;13435:2:114;788:34:47;;;13417:21:114;13474:2;13454:18;;;13447:30;13513:26;13493:18;;;13486:54;13557:18;;788:34:47;13233:348:114;730:345:47;852:35;843:5;:44;;;;;;;;:::i;:::-;;839:236;;903:41;;-1:-1:-1;;;903:41:47;;13788:2:114;903:41:47;;;13770:21:114;13827:2;13807:18;;;13800:30;13866:33;13846:18;;;13839:61;13917:18;;903:41:47;13586:355:114;839:236:47;974:30;965:5;:39;;;;;;;;:::i;:::-;;961:114;;1020:44;;-1:-1:-1;;;1020:44:47;;14148:2:114;1020:44:47;;;14130:21:114;14187:2;14167:18;;;14160:30;14226:34;14206:18;;;14199:62;-1:-1:-1;;;14277:18:114;;;14270:32;14319:19;;1020:44:47;13946:398:114;2536:245:44;2597:7;2669:4;2633:40;;2696:2;2687:11;;2683:69;;;2721:20;;-1:-1:-1;;;2721:20:44;;;;;;;;;;;14:289:114;56:3;94:5;88:12;121:6;116:3;109:19;177:6;170:4;163:5;159:16;152:4;147:3;143:14;137:47;229:1;222:4;213:6;208:3;204:16;200:27;193:38;292:4;285:2;281:7;276:2;268:6;264:15;260:29;255:3;251:39;247:50;240:57;;;14:289;;;;:::o;308:220::-;457:2;446:9;439:21;420:4;477:45;518:2;507:9;503:18;495:6;477:45;:::i;:::-;469:53;308:220;-1:-1:-1;;;308:220:114:o;533:173::-;601:20;;-1:-1:-1;;;;;650:31:114;;640:42;;630:70;;696:1;693;686:12;630:70;533:173;;;:::o;711:300::-;779:6;787;840:2;828:9;819:7;815:23;811:32;808:52;;;856:1;853;846:12;808:52;879:29;898:9;879:29;:::i;:::-;869:39;977:2;962:18;;;;949:32;;-1:-1:-1;;;711:300:114:o;1390:374::-;1467:6;1475;1483;1536:2;1524:9;1515:7;1511:23;1507:32;1504:52;;;1552:1;1549;1542:12;1504:52;1575:29;1594:9;1575:29;:::i;:::-;1565:39;;1623:38;1657:2;1646:9;1642:18;1623:38;:::i;:::-;1390:374;;1613:48;;-1:-1:-1;;;1730:2:114;1715:18;;;;1702:32;;1390:374::o;1769:186::-;1828:6;1881:2;1869:9;1860:7;1856:23;1852:32;1849:52;;;1897:1;1894;1887:12;1849:52;1920:29;1939:9;1920:29;:::i;2331:226::-;2390:6;2443:2;2431:9;2422:7;2418:23;2414:32;2411:52;;;2459:1;2456;2449:12;2411:52;-1:-1:-1;2504:23:114;;2331:226;-1:-1:-1;2331:226:114:o;2562:1238::-;2968:3;2963;2959:13;2951:6;2947:26;2936:9;2929:45;3010:3;3005:2;2994:9;2990:18;2983:31;2910:4;3037:46;3078:3;3067:9;3063:19;3055:6;3037:46;:::i;:::-;3131:9;3123:6;3119:22;3114:2;3103:9;3099:18;3092:50;3165:33;3191:6;3183;3165:33;:::i;:::-;3229:2;3214:18;;3207:34;;;-1:-1:-1;;;;;3278:32:114;;3272:3;3257:19;;3250:61;3298:3;3327:19;;3320:35;;;3392:22;;;3386:3;3371:19;;3364:51;3464:13;;3486:22;;;3536:2;3562:15;;;;-1:-1:-1;3524:15:114;;;;-1:-1:-1;3605:169:114;3619:6;3616:1;3613:13;3605:169;;;3680:13;;3668:26;;3723:2;3749:15;;;;3714:12;;;;3641:1;3634:9;3605:169;;;-1:-1:-1;3791:3:114;;2562:1238;-1:-1:-1;;;;;;;;;;;2562:1238:114:o;4110:903::-;4221:6;4229;4237;4245;4253;4261;4269;4322:3;4310:9;4301:7;4297:23;4293:33;4290:53;;;4339:1;4336;4329:12;4290:53;4362:29;4381:9;4362:29;:::i;:::-;4352:39;;4410:38;4444:2;4433:9;4429:18;4410:38;:::i;:::-;4400:48;-1:-1:-1;4517:2:114;4502:18;;4489:32;;-1:-1:-1;4618:2:114;4603:18;;4590:32;;-1:-1:-1;4700:3:114;4685:19;;4672:33;4749:4;4736:18;;4724:31;;4714:59;;4769:1;4766;4759:12;4714:59;4110:903;;;;-1:-1:-1;4110:903:114;;;;4792:7;4872:3;4857:19;;4844:33;;-1:-1:-1;4976:3:114;4961:19;;;4948:33;;4110:903;-1:-1:-1;;4110:903:114:o;5018:260::-;5086:6;5094;5147:2;5135:9;5126:7;5122:23;5118:32;5115:52;;;5163:1;5160;5153:12;5115:52;5186:29;5205:9;5186:29;:::i;:::-;5176:39;;5234:38;5268:2;5257:9;5253:18;5234:38;:::i;:::-;5224:48;;5018:260;;;;;:::o;5283:380::-;5362:1;5358:12;;;;5405;;;5426:61;;5480:4;5472:6;5468:17;5458:27;;5426:61;5533:2;5525:6;5522:14;5502:18;5499:38;5496:161;;5579:10;5574:3;5570:20;5567:1;5560:31;5614:4;5611:1;5604:15;5642:4;5639:1;5632:15;5668:127;5729:10;5724:3;5720:20;5717:1;5710:31;5760:4;5757:1;5750:15;5784:4;5781:1;5774:15;5800:217;5840:1;5866;5856:132;;5910:10;5905:3;5901:20;5898:1;5891:31;5945:4;5942:1;5935:15;5973:4;5970:1;5963:15;5856:132;-1:-1:-1;6002:9:114;;5800:217::o;6022:125::-;6087:9;;;6108:10;;;6105:36;;;6121:18;;:::i;6152:346::-;6354:2;6336:21;;;6393:2;6373:18;;;6366:30;-1:-1:-1;;;6427:2:114;6412:18;;6405:52;6489:2;6474:18;;6152:346::o;6503:128::-;6570:9;;;6591:11;;;6588:37;;;6605:18;;:::i;6636:168::-;6709:9;;;6740;;6757:15;;;6751:22;;6737:37;6727:71;;6778:18;;:::i;13101:127::-;13162:10;13157:3;13153:20;13150:1;13143:31;13193:4;13190:1;13183:15;13217:4;13214:1;13207:15","linkReferences":{},"immutableReferences":{"53114":[{"start":3448,"length":32}],"53116":[{"start":3406,"length":32}],"53118":[{"start":3364,"length":32}],"53120":[{"start":3529,"length":32}],"53122":[{"start":3569,"length":32}],"53125":[{"start":1579,"length":32}],"53128":[{"start":1622,"length":32}]}},"methodIdentifiers":{"DOMAIN_SEPARATOR()":"3644e515","VERSION()":"ffa1ad74","allowance(address,address)":"dd62ed3e","approve(address,uint256)":"095ea7b3","balanceOf(address)":"70a08231","burn(uint256)":"42966c68","decimals()":"313ce567","decreaseAllowance(address,uint256)":"a457c2d7","eip712Domain()":"84b0196e","increaseAllowance(address,uint256)":"39509351","minStake()":"375b3c0a","mint(uint256)":"a0712d68","name()":"06fdde03","nonces(address)":"7ecebe00","outstandingSupply()":"caacafe2","peripheryContracts()":"b79be3f0","permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":"d505accf","previousTotalSupply()":"80ba0f0f","setLiquidityManager(address)":"3c1624d4","setPreviousTotalSupply(uint256)":"9c547c4b","setStakingPool(address)":"3028f63a","symbol()":"95d89b41","totalSupply()":"18160ddd","transfer(address,uint256)":"a9059cbb","transferFrom(address,address,uint256)":"23b872dd"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AddressAlreadySet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidShortString\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"}],\"name\":\"StringTooLong\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddressInSetter\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EIP712DomainChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"eip712Domain\",\"outputs\":[{\"internalType\":\"bytes1\",\"name\":\"fields\",\"type\":\"bytes1\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"verifyingContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"extensions\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minStake\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"outstandingSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"peripheryContracts\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"previousTotalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"liquidityManager_\",\"type\":\"address\"}],\"name\":\"setLiquidityManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_ts\",\"type\":\"uint256\"}],\"name\":\"setPreviousTotalSupply\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"stakingPool_\",\"type\":\"address\"}],\"name\":\"setStakingPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Key features: - Controlled minting exclusively by LiquidityManager - Tax collection and redistribution mechanism through staking pool - 20% supply cap for staking (20,000 positions max) - Staking pool receives proportional share of all mints/burns\",\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"EIP712DomainChanged()\":{\"details\":\"MAY be emitted to signal that the domain could have changed.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"DOMAIN_SEPARATOR()\":{\"details\":\"Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\"},\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"burn(uint256)\":{\"details\":\"When tokens are burned, the total supply shrinks, making excess tokens in the staking pool unnecessary.      These excess tokens are burned to maintain the guaranteed fixed percentage of the total supply for stakers.\",\"params\":{\"_amount\":\"The number of tokens to burn.\"}},\"constructor\":{\"params\":{\"name_\":\"The name of the token\",\"symbol_\":\"The symbol of the token\"}},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"decreaseAllowance(address,uint256)\":{\"details\":\"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.\"},\"eip712Domain()\":{\"details\":\"See {EIP-5267}. _Available since v4.9._\"},\"increaseAllowance(address,uint256)\":{\"details\":\"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.\"},\"minStake()\":{\"returns\":{\"_0\":\"The minimum stake amount\"}},\"mint(uint256)\":{\"details\":\"Tokens minted are managed as community liquidity in the Uniswap pool to stabilize KRAIKEN prices.      Only callable by the Liquidity Manager. Minting rules and limits are defined externally.\",\"params\":{\"_amount\":\"The number of tokens to mint.\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"nonces(address)\":{\"details\":\"Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times.\"},\"outstandingSupply()\":{\"returns\":{\"_0\":\"The outstanding supply\"}},\"peripheryContracts()\":{\"returns\":{\"_0\":\"The addresses of the TWAB controller, liquidity manager, staking pool, and liquidity pool\"}},\"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)\":{\"details\":\"Sets `value` as the allowance of `spender` over ``owner``'s tokens, given ``owner``'s signed approval. IMPORTANT: The same issues {IERC20-approve} has related to transaction ordering also apply here. Emits an {Approval} event. Requirements: - `spender` cannot be the zero address. - `deadline` must be a timestamp in the future. - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` over the EIP712-formatted function arguments. - the signature must use ``owner``'s current nonce (see {nonces}). For more information on the signature format, see the https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section]. CAUTION: See Security Considerations above.\"},\"setLiquidityManager(address)\":{\"details\":\"Should be called only once right after the contract deployment to set the liquidity manager address.      Throws AddressAlreadySet if called more than once.\",\"params\":{\"liquidityManager_\":\"The address of the liquidity manager.\"}},\"setPreviousTotalSupply(uint256)\":{\"params\":{\"_ts\":\"The previous total supply value\"}},\"setStakingPool(address)\":{\"details\":\"Should be called only once right after the contract deployment to set the staking pool address.      Throws AddressAlreadySet if called more than once.\",\"params\":{\"stakingPool_\":\"The address of the staking pool.\"}},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.\"}},\"title\":\"stakeable ERC20 Token\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"VERSION()\":{\"notice\":\"Protocol version for data structure compatibility. Increment when making breaking changes to TAX_RATES, events, or core data structures. Indexers and frontends validate against this to ensure sync. Version History: - v1: Initial deployment with 30-tier TAX_RATES - v2: OptimizerV3, VWAP mirror floor, directional VWAP recording\"},\"burn(uint256)\":{\"notice\":\"Allows the liquidity manager to burn tokens from its account, adjusting the staking pool accordingly.\"},\"constructor\":{\"notice\":\"Constructor for the Kraiken token\"},\"minStake()\":{\"notice\":\"Calculates the minimum stake based on the previous total supply\"},\"mint(uint256)\":{\"notice\":\"Allows the liquidity manager to mint tokens for itself.\"},\"outstandingSupply()\":{\"notice\":\"Returns the outstanding supply, excluding the balances of the liquidity pool and liquidity manager\"},\"peripheryContracts()\":{\"notice\":\"Returns the addresses of the periphery contracts\"},\"setLiquidityManager(address)\":{\"notice\":\"Sets the address for the liquidityManager. Used once post-deployment to initialize the contract.\"},\"setPreviousTotalSupply(uint256)\":{\"notice\":\"Sets the previous total supply\"},\"setStakingPool(address)\":{\"notice\":\"Sets the address for the stakingPool. Used once post-deployment to initialize the contract.\"}},\"notice\":\"This contract implements an ERC20 token with mechanisms for minting and burning in which a single account (staking Pool) is proportionally receiving a share. Only the liquidity manager has permission to manage token supply.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/Kraiken.sol\":\"Kraiken\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@aperture/uni-v3-lib/=lib/uni-v3-lib/src/\",\":@openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":@uniswap-v3-core/=lib/uni-v3-lib/node_modules/@uniswap/v3-core/contracts/\",\":@uniswap-v3-periphery/=lib/uni-v3-lib/node_modules/@uniswap/v3-periphery/contracts/\",\":@uniswap/=lib/uni-v3-lib/node_modules/@uniswap/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":base64-sol/=lib/uni-v3-lib/node_modules/base64-sol/\",\":ds-test/=lib/solmate/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":pt-v5-twab-controller/=lib/pt-v5-twab-controller/src/\",\":ring-buffer-lib/=lib/pt-v5-twab-controller/lib/ring-buffer-lib/src/\",\":solady/=lib/uni-v3-lib/node_modules/solady/\",\":solmate/=lib/solmate/src/\",\":uni-v3-lib/=lib/uni-v3-lib/src/\"]},\"sources\":{\"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol\":{\"keccak256\":\"0xac6c2efc64baccbde4904ae18ed45139c9aa8cff96d6888344d1e4d2eb8b659f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6e416a280c610b6b7a5f158e4a41aacfaec01ef14d5d1de13b46be9e090265fc\",\"dweb:/ipfs/QmYZP2KrdyccBbhLZT42auhvBTMkwiwUS3V6HWb42rbwbG\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15\",\"dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5\",\"dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Permit.sol\":{\"keccak256\":\"0xbb16110ffe0b625944fe7dd97adcf1158e514185c956a5628bc09be90d606174\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b5b412e554a4dd37a50f89ffcd7b9a6ef2ae5064f37619f89343b23d58ce89ca\",\"dweb:/ipfs/QmPWMdBvdFk8WBVv625wd1Ar7aehnBWtj1XfFRrRL5KpxJ\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd\",\"dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"keccak256\":\"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://28879d01fd22c07b44f006612775f8577defbe459cb01685c5e25cd518c91a71\",\"dweb:/ipfs/QmVgfkwv2Fxw6hhTcDUZhE7NkoSKjab3ipM7UaRbt6uXb5\"]},\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c\",\"dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h\"]},\"lib/openzeppelin-contracts/contracts/utils/Counters.sol\":{\"keccak256\":\"0xf0018c2440fbe238dd3a8732fa8e17a0f9dce84d31451dc8a32f6d62b349c9f1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://59e1c62884d55b70f3ae5432b44bb3166ad71ae3acd19c57ab6ddc3c87c325ee\",\"dweb:/ipfs/QmezuXg5GK5oeA4F91EZhozBFekhq5TD966bHPH18cCqhu\"]},\"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol\":{\"keccak256\":\"0xc0e310c163edf15db45d4ff938113ab357f94fa86e61ea8e790853c4d2e13256\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://04db5bc05dcb05ba1f6ca2dfbead17adc8a2e2f911aa80b05e7a36d9eaf96516\",\"dweb:/ipfs/QmVkfHZbXVBUPsTopueCn3qGJX8aEjahFF3Fn4NcygLNm5\"]},\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xf09e68aa0dc6722a25bc46490e8d48ed864466d17313b8a0b254c36b54e49899\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e26daf81e2252dc1fe1ce0e4b55c2eb7c6d1ee84ae6558d1a9554432ea1d32da\",\"dweb:/ipfs/Qmb1UANWiWq5pCKbmHSu772hd4nt374dVaghGmwSVNuk8Q\"]},\"lib/openzeppelin-contracts/contracts/utils/Strings.sol\":{\"keccak256\":\"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f\",\"dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x809bc3edb4bcbef8263fa616c1b60ee0004b50a8a1bfa164d8f57fd31f520c58\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8b93a1e39a4a19eba1600b92c96f435442db88cac91e315c8291547a2a7bcfe2\",\"dweb:/ipfs/QmTm34KVe6uZBZwq8dZDNWwPcm24qBJdxqL3rPxBJ4LrMv\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol\":{\"keccak256\":\"0x8432884527a7ad91e6eed1cfc5a0811ae2073e5bca107bd0ca442e9236b03dbd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e3aa0eadab7aafcf91a95684765f778f64386f0368de88522ce873c21385278a\",\"dweb:/ipfs/QmPfaVAqWgH1QsT3dHVuL6jwMZbVKdoP8w1PvpiPT2FPWd\"]},\"lib/openzeppelin-contracts/contracts/utils/math/Math.sol\":{\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c\",\"dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS\"]},\"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7\",\"dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6\"]},\"src/Kraiken.sol\":{\"keccak256\":\"0x1c942bc6eacd6f413c7e58e5d313e0a0b6ec642b4fcf28aedc7990f35df1d291\",\"license\":\"GPL-3.0-or-later\",\"urls\":[\"bzz-raw://8ba5284cf487489f6e33015ffcabafed502462e6ec27683e782066cc98cf861f\",\"dweb:/ipfs/Qme8uPk4hQPNDqMYG2NVxhwpCuq2a32mQbsTk4sdHPPhjx\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"error","name":"AddressAlreadySet"},{"inputs":[],"type":"error","name":"InvalidShortString"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"type":"error","name":"StringTooLong"},{"inputs":[],"type":"error","name":"ZeroAddressInSetter"},{"inputs":[{"internalType":"address","name":"owner","type":"address","indexed":true},{"internalType":"address","name":"spender","type":"address","indexed":true},{"internalType":"uint256","name":"value","type":"uint256","indexed":false}],"type":"event","name":"Approval","anonymous":false},{"inputs":[],"type":"event","name":"EIP712DomainChanged","anonymous":false},{"inputs":[{"internalType":"address","name":"from","type":"address","indexed":true},{"internalType":"address","name":"to","type":"address","indexed":true},{"internalType":"uint256","name":"value","type":"uint256","indexed":false}],"type":"event","name":"Transfer","anonymous":false},{"inputs":[],"stateMutability":"view","type":"function","name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"VERSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"stateMutability":"view","type":"function","name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"stateMutability":"view","type":"function","name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"burn"},{"inputs":[],"stateMutability":"view","type":"function","name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}]},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}]},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"minStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"mint"},{"inputs":[],"stateMutability":"view","type":"function","name":"name","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function","name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"outstandingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"peripheryContracts","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"stateMutability":"nonpayable","type":"function","name":"permit"},{"inputs":[],"stateMutability":"view","type":"function","name":"previousTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"liquidityManager_","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"setLiquidityManager"},{"inputs":[{"internalType":"uint256","name":"_ts","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"setPreviousTotalSupply"},{"inputs":[{"internalType":"address","name":"stakingPool_","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"setStakingPool"},{"inputs":[],"stateMutability":"view","type":"function","name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}]}],"devdoc":{"kind":"dev","methods":{"DOMAIN_SEPARATOR()":{"details":"Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"burn(uint256)":{"details":"When tokens are burned, the total supply shrinks, making excess tokens in the staking pool unnecessary.      These excess tokens are burned to maintain the guaranteed fixed percentage of the total supply for stakers.","params":{"_amount":"The number of tokens to burn."}},"constructor":{"params":{"name_":"The name of the token","symbol_":"The symbol of the token"}},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"eip712Domain()":{"details":"See {EIP-5267}. _Available since v4.9._"},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"minStake()":{"returns":{"_0":"The minimum stake amount"}},"mint(uint256)":{"details":"Tokens minted are managed as community liquidity in the Uniswap pool to stabilize KRAIKEN prices.      Only callable by the Liquidity Manager. Minting rules and limits are defined externally.","params":{"_amount":"The number of tokens to mint."}},"name()":{"details":"Returns the name of the token."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times."},"outstandingSupply()":{"returns":{"_0":"The outstanding supply"}},"peripheryContracts()":{"returns":{"_0":"The addresses of the TWAB controller, liquidity manager, staking pool, and liquidity pool"}},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over ``owner``'s tokens, given ``owner``'s signed approval. IMPORTANT: The same issues {IERC20-approve} has related to transaction ordering also apply here. Emits an {Approval} event. Requirements: - `spender` cannot be the zero address. - `deadline` must be a timestamp in the future. - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` over the EIP712-formatted function arguments. - the signature must use ``owner``'s current nonce (see {nonces}). For more information on the signature format, see the https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section]. CAUTION: See Security Considerations above."},"setLiquidityManager(address)":{"details":"Should be called only once right after the contract deployment to set the liquidity manager address.      Throws AddressAlreadySet if called more than once.","params":{"liquidityManager_":"The address of the liquidity manager."}},"setPreviousTotalSupply(uint256)":{"params":{"_ts":"The previous total supply value"}},"setStakingPool(address)":{"details":"Should be called only once right after the contract deployment to set the staking pool address.      Throws AddressAlreadySet if called more than once.","params":{"stakingPool_":"The address of the staking pool."}},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"userdoc":{"kind":"user","methods":{"VERSION()":{"notice":"Protocol version for data structure compatibility. Increment when making breaking changes to TAX_RATES, events, or core data structures. Indexers and frontends validate against this to ensure sync. Version History: - v1: Initial deployment with 30-tier TAX_RATES - v2: OptimizerV3, VWAP mirror floor, directional VWAP recording"},"burn(uint256)":{"notice":"Allows the liquidity manager to burn tokens from its account, adjusting the staking pool accordingly."},"constructor":{"notice":"Constructor for the Kraiken token"},"minStake()":{"notice":"Calculates the minimum stake based on the previous total supply"},"mint(uint256)":{"notice":"Allows the liquidity manager to mint tokens for itself."},"outstandingSupply()":{"notice":"Returns the outstanding supply, excluding the balances of the liquidity pool and liquidity manager"},"peripheryContracts()":{"notice":"Returns the addresses of the periphery contracts"},"setLiquidityManager(address)":{"notice":"Sets the address for the liquidityManager. Used once post-deployment to initialize the contract."},"setPreviousTotalSupply(uint256)":{"notice":"Sets the previous total supply"},"setStakingPool(address)":{"notice":"Sets the address for the stakingPool. Used once post-deployment to initialize the contract."}},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@aperture/uni-v3-lib/=lib/uni-v3-lib/src/","@openzeppelin/=lib/openzeppelin-contracts/contracts/","@uniswap-v3-core/=lib/uni-v3-lib/node_modules/@uniswap/v3-core/contracts/","@uniswap-v3-periphery/=lib/uni-v3-lib/node_modules/@uniswap/v3-periphery/contracts/","@uniswap/=lib/uni-v3-lib/node_modules/@uniswap/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","base64-sol/=lib/uni-v3-lib/node_modules/base64-sol/","ds-test/=lib/solmate/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/","openzeppelin/=lib/openzeppelin-contracts/contracts/","pt-v5-twab-controller/=lib/pt-v5-twab-controller/src/","ring-buffer-lib/=lib/pt-v5-twab-controller/lib/ring-buffer-lib/src/","solady/=lib/uni-v3-lib/node_modules/solady/","solmate/=lib/solmate/src/","uni-v3-lib/=lib/uni-v3-lib/src/"],"optimizer":{"enabled":true,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/Kraiken.sol":"Kraiken"},"evmVersion":"prague","libraries":{}},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"keccak256":"0xac6c2efc64baccbde4904ae18ed45139c9aa8cff96d6888344d1e4d2eb8b659f","urls":["bzz-raw://6e416a280c610b6b7a5f158e4a41aacfaec01ef14d5d1de13b46be9e090265fc","dweb:/ipfs/QmYZP2KrdyccBbhLZT42auhvBTMkwiwUS3V6HWb42rbwbG"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol":{"keccak256":"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c","urls":["bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15","dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","urls":["bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5","dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Permit.sol":{"keccak256":"0xbb16110ffe0b625944fe7dd97adcf1158e514185c956a5628bc09be90d606174","urls":["bzz-raw://b5b412e554a4dd37a50f89ffcd7b9a6ef2ae5064f37619f89343b23d58ce89ca","dweb:/ipfs/QmPWMdBvdFk8WBVv625wd1Ar7aehnBWtj1XfFRrRL5KpxJ"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca","urls":["bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd","dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol":{"keccak256":"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69","urls":["bzz-raw://28879d01fd22c07b44f006612775f8577defbe459cb01685c5e25cd518c91a71","dweb:/ipfs/QmVgfkwv2Fxw6hhTcDUZhE7NkoSKjab3ipM7UaRbt6uXb5"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439","urls":["bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c","dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Counters.sol":{"keccak256":"0xf0018c2440fbe238dd3a8732fa8e17a0f9dce84d31451dc8a32f6d62b349c9f1","urls":["bzz-raw://59e1c62884d55b70f3ae5432b44bb3166ad71ae3acd19c57ab6ddc3c87c325ee","dweb:/ipfs/QmezuXg5GK5oeA4F91EZhozBFekhq5TD966bHPH18cCqhu"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"keccak256":"0xc0e310c163edf15db45d4ff938113ab357f94fa86e61ea8e790853c4d2e13256","urls":["bzz-raw://04db5bc05dcb05ba1f6ca2dfbead17adc8a2e2f911aa80b05e7a36d9eaf96516","dweb:/ipfs/QmVkfHZbXVBUPsTopueCn3qGJX8aEjahFF3Fn4NcygLNm5"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"keccak256":"0xf09e68aa0dc6722a25bc46490e8d48ed864466d17313b8a0b254c36b54e49899","urls":["bzz-raw://e26daf81e2252dc1fe1ce0e4b55c2eb7c6d1ee84ae6558d1a9554432ea1d32da","dweb:/ipfs/Qmb1UANWiWq5pCKbmHSu772hd4nt374dVaghGmwSVNuk8Q"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"keccak256":"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0","urls":["bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f","dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"keccak256":"0x809bc3edb4bcbef8263fa616c1b60ee0004b50a8a1bfa164d8f57fd31f520c58","urls":["bzz-raw://8b93a1e39a4a19eba1600b92c96f435442db88cac91e315c8291547a2a7bcfe2","dweb:/ipfs/QmTm34KVe6uZBZwq8dZDNWwPcm24qBJdxqL3rPxBJ4LrMv"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"keccak256":"0x8432884527a7ad91e6eed1cfc5a0811ae2073e5bca107bd0ca442e9236b03dbd","urls":["bzz-raw://e3aa0eadab7aafcf91a95684765f778f64386f0368de88522ce873c21385278a","dweb:/ipfs/QmPfaVAqWgH1QsT3dHVuL6jwMZbVKdoP8w1PvpiPT2FPWd"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"keccak256":"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3","urls":["bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c","dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"keccak256":"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc","urls":["bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7","dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6"],"license":"MIT"},"src/Kraiken.sol":{"keccak256":"0x1c942bc6eacd6f413c7e58e5d313e0a0b6ec642b4fcf28aedc7990f35df1d291","urls":["bzz-raw://8ba5284cf487489f6e33015ffcabafed502462e6ec27683e782066cc98cf861f","dweb:/ipfs/Qme8uPk4hQPNDqMYG2NVxhwpCuq2a32mQbsTk4sdHPPhjx"],"license":"GPL-3.0-or-later"}},"version":1},"id":80}
\ No newline at end of file
diff --git a/services/ponder/abis/Stake.json b/services/ponder/abis/Stake.json
index 0e5950f..b1b3a22 100644
--- a/services/ponder/abis/Stake.json
+++ b/services/ponder/abis/Stake.json
@@ -1 +1 @@
-[{"inputs":[{"internalType":"address","name":"_harberg","type":"address"},{"internalType":"address","name":"_taxReceiver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"stakeWanted","type":"uint256"},{"internalType":"uint256","name":"availableStake","type":"uint256"}],"name":"ExceededAvailableStake","type":"error"},{"inputs":[{"internalType":"address","name":"requester","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"NoPermission","type":"error"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"},{"internalType":"address","name":"requester","type":"address"}],"name":"PositionNotFound","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"minStake","type":"uint256"}],"name":"StakeTooLow","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint64","name":"taxRateWanted","type":"uint64"},{"internalType":"uint64","name":"taxRateMet","type":"uint64"},{"internalType":"uint256","name":"positionId","type":"uint256"}],"name":"TaxTooLow","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"stakeWanted","type":"uint256"},{"internalType":"uint256","name":"availableStake","type":"uint256"},{"internalType":"uint256","name":"smallestShare","type":"uint256"}],"name":"TooMuchSnatch","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"harbergDeposit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"share","type":"uint256"},{"indexed":false,"internalType":"uint32","name":"taxRate","type":"uint32"}],"name":"PositionCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"newTaxRate","type":"uint256"}],"name":"PositionRateHiked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"harbergPayout","type":"uint256"}],"name":"PositionRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"newShares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"harbergPayout","type":"uint256"}],"name":"PositionShrunk","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"taxPaid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newShares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"taxRate","type":"uint256"}],"name":"PositionTaxPaid","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"TAX_RATES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"assetsToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"},{"internalType":"uint32","name":"taxRate","type":"uint32"}],"name":"changeTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"name":"exitPosition","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAverageTaxRate","outputs":[{"internalType":"uint256","name":"averageTaxRate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPercentageStaked","outputs":[{"internalType":"uint256","name":"percentageStaked","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextPositionId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"outstandingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"name":"payTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint32","name":"taxRate","type":"uint32"},{"internalType":"uint256[]","name":"positionsToSnatch","type":"uint256[]"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permitAndSnatch","outputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"positions","outputs":[{"internalType":"uint256","name":"share","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint32","name":"creationTime","type":"uint32"},{"internalType":"uint32","name":"lastTaxTime","type":"uint32"},{"internalType":"uint32","name":"taxRate","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"sharesToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint32","name":"taxRate","type":"uint32"},{"internalType":"uint256[]","name":"positionsToSnatch","type":"uint256[]"}],"name":"snatch","outputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"},{"internalType":"uint256","name":"taxFloorDuration","type":"uint256"}],"name":"taxDue","outputs":[{"internalType":"uint256","name":"amountDue","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"totalSharesAtTaxRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
\ No newline at end of file
+{"abi":[{"type":"constructor","inputs":[{"name":"_kraiken","type":"address","internalType":"address"},{"name":"_taxReceiver","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"type":"function","name":"TAX_RATES","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"assetsToShares","inputs":[{"name":"assets","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"changeTax","inputs":[{"name":"positionId","type":"uint256","internalType":"uint256"},{"name":"taxRate","type":"uint32","internalType":"uint32"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"exitPosition","inputs":[{"name":"positionId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"getAverageTaxRate","inputs":[],"outputs":[{"name":"averageTaxRate","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"getPercentageStaked","inputs":[],"outputs":[{"name":"percentageStaked","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"nextPositionId","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"outstandingStake","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"payTax","inputs":[{"name":"positionId","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"permitAndSnatch","inputs":[{"name":"assets","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"taxRate","type":"uint32","internalType":"uint32"},{"name":"positionsToSnatch","type":"uint256[]","internalType":"uint256[]"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"positionId","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"function","name":"positions","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"share","type":"uint256","internalType":"uint256"},{"name":"owner","type":"address","internalType":"address"},{"name":"creationTime","type":"uint32","internalType":"uint32"},{"name":"lastTaxTime","type":"uint32","internalType":"uint32"},{"name":"taxRate","type":"uint32","internalType":"uint32"}],"stateMutability":"view"},{"type":"function","name":"sharesToAssets","inputs":[{"name":"shares","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"snatch","inputs":[{"name":"assets","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"taxRate","type":"uint32","internalType":"uint32"},{"name":"positionsToSnatch","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"positionId","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"function","name":"taxDue","inputs":[{"name":"positionId","type":"uint256","internalType":"uint256"},{"name":"taxFloorDuration","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"amountDue","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"totalSharesAtTaxRate","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"event","name":"PositionCreated","inputs":[{"name":"positionId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"kraikenDeposit","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"share","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"taxRate","type":"uint32","indexed":false,"internalType":"uint32"}],"anonymous":false},{"type":"event","name":"PositionRateHiked","inputs":[{"name":"positionId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"newTaxRate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"PositionRemoved","inputs":[{"name":"positionId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"kraikenPayout","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"PositionShrunk","inputs":[{"name":"positionId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"newShares","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"kraikenPayout","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"PositionTaxPaid","inputs":[{"name":"positionId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"taxPaid","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newShares","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"taxRate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"error","name":"ExceededAvailableStake","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"stakeWanted","type":"uint256","internalType":"uint256"},{"name":"availableStake","type":"uint256","internalType":"uint256"}]},{"type":"error","name":"NoPermission","inputs":[{"name":"requester","type":"address","internalType":"address"},{"name":"owner","type":"address","internalType":"address"}]},{"type":"error","name":"PositionNotFound","inputs":[{"name":"positionId","type":"uint256","internalType":"uint256"},{"name":"requester","type":"address","internalType":"address"}]},{"type":"error","name":"StakeTooLow","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"assets","type":"uint256","internalType":"uint256"},{"name":"minStake","type":"uint256","internalType":"uint256"}]},{"type":"error","name":"TaxTooLow","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"taxRateWanted","type":"uint64","internalType":"uint64"},{"name":"taxRateMet","type":"uint64","internalType":"uint64"},{"name":"positionId","type":"uint256","internalType":"uint256"}]},{"type":"error","name":"TooMuchSnatch","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"stakeWanted","type":"uint256","internalType":"uint256"},{"name":"availableStake","type":"uint256","internalType":"uint256"},{"name":"smallestShare","type":"uint256","internalType":"uint256"}]}],"bytecode":{"object":"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","sourceMap":"2130:5:85:-:0;2096:39;;2526:180;1875:17576;2526:180;2564:1;1875:17576;2526:180;;;2567:1;2526:180;;2570:1;2526:180;;2573:1;2526:180;;;;2576:2;2526:180;;2580:2;2526:180;;2584:2;2526:180;;2588:2;2526:180;;;;2592:2;2526:180;;2596:2;2526:180;;2600:2;2526:180;;2604:2;2526:180;;2608:3;2526:180;;2613:3;2526:180;;2618:3;2526:180;;2623:3;2526:180;;;;;;;2633:3;2526:180;;2638:3;2526:180;;2643:3;2526:180;;2648:3;2526:180;;2653:4;2526:180;;2659:4;2526:180;;2665:4;2526:180;;2671:4;2526:180;;2677:4;2526:180;;2683:4;2526:180;;2689:4;2526:180;;2695:4;2526:180;;2701:4;2526:180;;;;2564:1;1875:17576;2526:180;:::i;:::-;;4695:382;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4757:27:85;;;;;;;4794:26;;;;;4872:14;;4851:18;;;-1:-1:-1;;;4851:18:85;;;;4872:14;;4757:27;4851:16;;:18;;;;;;;;;;;;;;;4757:27;4851:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;;;;;;:::i;:::-;4844:43;;:2;:43;:::i;:::-;4830:57;;4950:7;4933:14;:24;5053:9;:16;-1:-1:-1;;;;;5039:31:85;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5039:31:85;-1:-1:-1;5016:54:85;;;;:20;;:54;;;;;;:::i;:::-;;4695:382;;1875:17576;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1875:17576:85;;;-1:-1:-1;1875:17576:85;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:177:114;93:13;;-1:-1:-1;;;;;135:31:114;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;494:273::-;562:6;615:2;603:9;594:7;590:23;586:32;583:52;;;631:1;628;621:12;583:52;663:9;657:16;713:4;706:5;702:16;695:5;692:27;682:55;;733:1;730;723:12;682:55;756:5;494:273;-1:-1:-1;;;494:273:114:o;772:127::-;833:10;828:3;824:20;821:1;814:31;864:4;861:1;854:15;888:4;885:1;878:15;904:125;969:9;;;990:10;;;987:36;;;1003:18;;:::i;:::-;904:125;;;;:::o;1034:375::-;1122:1;1140:5;1154:249;1175:1;1165:8;1162:15;1154:249;;;1225:4;1220:3;1216:14;1210:4;1207:24;1204:50;;;1234:18;;:::i;:::-;1284:1;1274:8;1270:16;1267:49;;;1298:16;;;;1267:49;1381:1;1377:16;;;;;1337:15;;1154:249;;;1034:375;;;;;;:::o;1414:902::-;1463:5;1493:8;1483:80;;-1:-1:-1;1534:1:114;1548:5;;1483:80;1582:4;1572:76;;-1:-1:-1;1619:1:114;1633:5;;1572:76;1664:4;1682:1;1677:59;;;;1750:1;1745:174;;;;1657:262;;1677:59;1707:1;1698:10;;1721:5;;;1745:174;1782:3;1772:8;1769:17;1766:43;;;1789:18;;:::i;:::-;-1:-1:-1;;1845:1:114;1831:16;;1904:5;;1657:262;;2003:2;1993:8;1990:16;1984:3;1978:4;1975:13;1971:36;1965:2;1955:8;1952:16;1947:2;1941:4;1938:12;1934:35;1931:77;1928:203;;;-1:-1:-1;2040:19:114;;;2116:5;;1928:203;2163:42;-1:-1:-1;;2188:8:114;2182:4;2163:42;:::i;:::-;2241:6;2237:1;2233:6;2229:19;2220:7;2217:32;2214:58;;;2252:18;;:::i;:::-;2290:20;;1414:902;-1:-1:-1;;;1414:902:114:o;2321:131::-;2381:5;2410:36;2437:8;2431:4;2410:36;:::i;2457:127::-;2518:10;2513:3;2509:20;2506:1;2499:31;2549:4;2546:1;2539:15;2573:4;2570:1;2563:15;2457:127;1875:17576:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f5ffd5b50600436106100fb575f3560e01c806399fbab8811610093578063cbcebdba11610063578063cbcebdba14610268578063e0b231fa1461027b578063e95beb931461028e578063febf6b7b14610296575f5ffd5b806399fbab88146101a15780639d8e5ea71461022f578063a05aaf5014610242578063b8b1bc5114610255575f5ffd5b80635cb36034116100ce5780635cb360341461015d57806378dc9059146101705780637fe0c85014610185578063899346c714610198575f5ffd5b806313f5c726146100ff57806318160ddd1461012557806321139a011461014c5780635343275014610154575b5f5ffd5b61011261010d366004611abc565b6102a9565b6040519081526020015b60405180910390f35b6101127f000000000000000000000000000000000000000000000000000000000000000081565b6101126102c8565b61011260025481565b61011261016b366004611b49565b610392565b61018361017e366004611abc565b610452565b005b610112610193366004611abc565b6104fe565b61011260035481565b6101f46101af366004611abc565b60046020525f9081526040902080546001909101546001600160a01b0381169063ffffffff600160a01b8204811691600160c01b8104821691600160e01b9091041685565b604080519586526001600160a01b03909416602086015263ffffffff928316938501939093528116606084015216608082015260a00161011c565b61011261023d366004611be7565b6105b1565b610183610250366004611abc565b6106aa565b610183610263366004611c07565b6106ff565b610112610276366004611abc565b61092d565b610112610289366004611abc565b61093c565b6101126109ea565b6101126102a4366004611c31565b610a08565b600181815481106102b8575f80fd5b5f91825260209091200154905081565b6002545f901561038f575f5b60015481101561033457600581815481106102f1576102f1611c9b565b905f5260205f2001546001828154811061030d5761030d611c9b565b905f5260205f2001546103209190611cc3565b61032a9083611cda565b91506001016102d4565b506002546103429082611d01565b6001805491925090610355908290611d20565b8154811061036557610365611c9b565b905f5260205f20015481670de0b6b3a76400006103829190611cc3565b61038c9190611d01565b90505b90565b60405163d505accf60e01b81526001600160a01b038981166004830152306024830152604482018b90526064820186905260ff8516608483015260a4820184905260c482018390525f917f00000000000000000000000000000000000000000000000000000000000000009091169063d505accf9060e4015f604051808303815f87803b158015610421575f5ffd5b505af1158015610433573d5f5f3e3d5ffd5b505050506104448a8a8a8a8a610a08565b9a9950505050505050505050565b5f81815260046020526040902060018101546001600160a01b031633146104a8576001810154604051637b653e7d60e11b81523360048201526001600160a01b0390911660248201526044015b60405180910390fd5b6001810154600160a01b900463ffffffff165f036104e25760405163d37d088960e01b81526004810183905233602482015260440161049f565b6104f082826203f4806110fd565b6104fa8282611476565b5050565b5f6105ab7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561055e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105829190611d33565b83907f00000000000000000000000000000000000000000000000000000000000000005f61157c565b92915050565b5f8281526004602052604081206001810154829084906105de90600160a01b900463ffffffff1642611d20565b106105e95742610606565b6001820154610606908590600160a01b900463ffffffff16611cda565b60018301549091505f9061062790600160c01b900463ffffffff1683611d20565b90505f610636845f01546104fe565b905060646301e1338083600187600101601c9054906101000a900463ffffffff1663ffffffff168154811061066d5761066d611c9b565b905f5260205f200154846106819190611cc3565b61068b9190611cc3565b6106959190611d01565b61069f9190611d01565b979650505050505050565b5f81815260046020526040812060018101549091600160a01b90910463ffffffff1690036106f45760405163d37d088960e01b81526004810183905233602482015260440161049f565b6104fa82825f6110fd565b60015463ffffffff82161061074f5760405162461bcd60e51b81526020600482015260166024820152757461782072617465206f7574206f6620626f756e647360501b604482015260640161049f565b5f82815260046020526040812060018101549091600160a01b90910463ffffffff1690036107995760405163d37d088960e01b81526004810184905233602482015260440161049f565b60018101546001600160a01b031633146107dd576001810154604051637b653e7d60e11b81523360048201526001600160a01b03909116602482015260440161049f565b600181015463ffffffff600160e01b9091048116908316116108395760405162461bcd60e51b81526020600482015260156024820152740e8c2f040e8dede40d8deee40e8de40e6dcc2e8c6d605b1b604482015260640161049f565b61084483825f6110fd565b80546001820154600580549091600160e01b900463ffffffff1690811061086d5761086d611c9b565b905f5260205f20015f8282546108839190611d20565b909155505080546005805463ffffffff85169081106108a4576108a4611c9b565b905f5260205f20015f8282546108ba9190611cda565b90915550506001810180546001600160e01b038116600160e01b63ffffffff86169081029182179093556040519283526001600160a01b039182169116179084907fe6767cb515204f8d7033d356fa5c77de82ad12fc94271799b5b8b1c7663369449060200160405180910390a3505050565b600581815481106102b8575f80fd5b5f6105ab7f00000000000000000000000000000000000000000000000000000000000000007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156109bd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109e19190611d33565b8491905f61157c565b5f6109f36115d9565b60025461038290670de0b6b3a7640000611cc3565b5f5f610a138761093c565b90505f7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663375b3c0a6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610a72573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a969190611d33565b905080881015610ad257604051635fa7efd160e11b81526001600160a01b0388166004820152602481018990526044810182905260640161049f565b5060015463ffffffff861610610b235760405162461bcd60e51b81526020600482015260166024820152757461782072617465206f7574206f6620626f756e647360501b604482015260640161049f565b6002547f0000000000000000000000000000000000000000000000000000000000000000905f90610b526115d9565b610b5c9190611d20565b905060028510610cf8575f5b610b73600187611d20565b811015610cf6575f60045f898985818110610b9057610b90611c9b565b9050602002013581526020019081526020015f2090508060010160149054906101000a900463ffffffff1663ffffffff165f03610c0d57878783818110610bd957610bd9611c9b565b60405163d37d088960e01b8152602090910292909201356004830152506001600160a01b038b16602482015260440161049f565b600181015463ffffffff600160e01b9091048116908a1611610c9a5760018101548a908a90600160e01b900463ffffffff168a8a86818110610c5157610c51611c9b565b60405163aed9ae5960e01b81526001600160a01b0396909616600487015263ffffffff94851660248701529290931660448501526020909102013560648301525060840161049f565b8054841115610ca857805493505b610ccb888884818110610cbd57610cbd611c9b565b90506020020135825f6110fd565b610ced888884818110610ce057610ce0611c9b565b9050602002013582611476565b50600101610b68565b505b600254610d036115d9565b610d0d9190611d20565b90508415610eb8575f610d21600187611d20565b90505f60045f898985818110610d3957610d39611c9b565b9050602002013581526020019081526020015f2090508060010160149054906101000a900463ffffffff1663ffffffff165f03610d8257878783818110610bd957610bd9611c9b565b600181015463ffffffff600160e01b9091048116908a1611610dc65760018101548a908a90600160e01b900463ffffffff168a8a86818110610c5157610c51611c9b565b8054841115610dd457805493505b610dfa888884818110610de957610de9611c9b565b90506020020135826203f4806110fd565b84831115610e3b576040516378147d3360e01b81526001600160a01b038b16600482015260248101869052604481018490526064810185905260840161049f565b5f610e468487611d20565b8254909150606490610e59906050611cc3565b610e639190611d01565b811115610e9157610e8c898985818110610e7f57610e7f611c9b565b9050602002013583611476565b610eb4565b610eb4898985818110610ea657610ea6611c9b565b905060200201358383611607565b5050505b600254610ec36115d9565b610ecd9190611d20565b905080831115610f09576040516312797e8f60e11b81526001600160a01b0389166004820152602481018490526044810182905260640161049f565b81610f148483611d20565b1115610f53576040516378147d3360e01b81526001600160a01b038916600482015260248101849052604481018290526064810183905260840161049f565b610f7f7f000000000000000000000000000000000000000000000000000000000000000033308c611751565b60038054905f610f8e83611d4a565b9190505593505f60045f8681526020019081526020015f20905083815f018190555088816001015f6101000a8154816001600160a01b0302191690836001600160a01b03160217905550428160010160186101000a81548163ffffffff021916908363ffffffff160217905550428160010160146101000a81548163ffffffff021916908363ffffffff1602179055508781600101601c6101000a81548163ffffffff021916908363ffffffff1602179055508360058963ffffffff168154811061105b5761105b611c9b565b905f5260205f20015f8282546110719190611cda565b925050819055508360025f8282546110899190611cda565b909155505060018101548154604080518d8152602081019290925263ffffffff600160e01b840416908201526001600160a01b039091169086907f8f7598451bc034be2bd3fe6e2f06af052c2dc238bb90bc6fb426754f043014629060600160405180910390a35050505095945050505050565b60018201545f90829061111d90600160a01b900463ffffffff1642611d20565b106111285742611145565b6001830154611145908390600160a01b900463ffffffff16611cda565b60018401549091505f9061116690600160c01b900463ffffffff1683611d20565b90505f611175855f01546104fe565b90505f60646301e1338084600189600101601c9054906101000a900463ffffffff1663ffffffff16815481106111ad576111ad611c9b565b905f5260205f200154856111c19190611cc3565b6111cb9190611cc3565b6111d59190611d01565b6111df9190611d01565b90508181106111eb5750805b5f6111f68284611d20565b111561130c575f61120a6102898385611d20565b90505f81885f015461121c9190611d20565b905080600589600101601c9054906101000a900463ffffffff1663ffffffff168154811061124c5761124c611c9b565b905f5260205f20015f8282546112629190611d20565b925050819055508060025f82825461127a9190611d20565b909155505081885560018801805463ffffffff428116600160c01b0263ffffffff60c01b1983168117938490556040805188815260208101889052600160e01b909504909216918401919091526001600160a01b03908116911617908a907fb0b012792448969fc7ffc769b83b27cda55565d5a592a63209be2a6f1c5764a69060600160405180910390a35050611422565b85546001870154600580549091600160e01b900463ffffffff1690811061133557611335611c9b565b905f5260205f20015f82825461134b9190611d20565b90915550508554600280545f90611363908490611d20565b90915550506001860154604080518381525f602082015263ffffffff600160e01b8404168183015290516001600160a01b039092169189917fb0b012792448969fc7ffc769b83b27cda55565d5a592a63209be2a6f1c5764a6919081900360600190a360018601546040515f81526001600160a01b039091169088907f6f0b3e0cf1a11235226a949a12602f7cae95c342402ec2f4183fd70eab9921d79060200160405180910390a36001860180546001600160c01b03191690555f86555b61146d7f00000000000000000000000000000000000000000000000000000000000000007f0000000000000000000000000000000000000000000000000000000000000000836117bc565b50505050505050565b80546001820154600580549091600160e01b900463ffffffff1690811061149f5761149f611c9b565b905f5260205f20015f8282546114b59190611d20565b90915550508054600280545f906114cd908490611d20565b9091555050600181015481546001600160a01b03909116905f906114f0906104fe565b9050816001600160a01b0316847f6f0b3e0cf1a11235226a949a12602f7cae95c342402ec2f4183fd70eab9921d78360405161152e91815260200190565b60405180910390a36001830180546001600160c01b03191690555f83556115767f000000000000000000000000000000000000000000000000000000000000000083836117bc565b50505050565b5f5f6115898686866117f1565b9050600183600281111561159f5761159f611d62565b1480156115bb57505f84806115b6576115b6611ced565b868809115b156115ce576115cb600182611cda565b90505b90505b949350505050565b5f606461038260147f0000000000000000000000000000000000000000000000000000000000000000611cc3565b8154811061164c5760405162461bcd60e51b81526020600482015260126024820152711c1bdcda5d1a5bdb881d1bdbc81cdb585b1b60721b604482015260640161049f565b5f611656826104fe565b905081835f015f82825461166a9190611d20565b90915550506001830154600580548492600160e01b900463ffffffff1690811061169657611696611c9b565b905f5260205f20015f8282546116ac9190611d20565b925050819055508160025f8282546116c49190611d20565b90915550506001830154835460408051918252602082018490526001600160a01b039092169186917fa2d77705aa53a16a9bf1d72a714fcb5a94cc2decf59925f07ead504c92668ee2910160405180910390a36001830154611576907f0000000000000000000000000000000000000000000000000000000000000000906001600160a01b0316836117bc565b6040516001600160a01b03808516602483015283166044820152606481018290526115769085906323b872dd60e01b906084015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526118dc565b6040516001600160a01b0383166024820152604481018290526117ec90849063a9059cbb60e01b90606401611785565b505050565b5f80805f19858709858702925082811083820303915050805f036118285783828161181e5761181e611ced565b04925050506118d5565b80841161186f5760405162461bcd60e51b81526020600482015260156024820152744d6174683a206d756c446976206f766572666c6f7760581b604482015260640161049f565b5f848688098519600190810187169687900496828603819004959092119093035f82900391909104909201919091029190911760038402600290811880860282030280860282030280860282030280860282030280860282030280860290910302029150505b9392505050565b5f611930826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166119af9092919063ffffffff16565b905080515f14806119505750808060200190518101906119509190611d76565b6117ec5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840161049f565b60606115d184845f85855f5f866001600160a01b031685876040516119d49190611d95565b5f6040518083038185875af1925050503d805f8114611a0e576040519150601f19603f3d011682016040523d82523d5f602084013e611a13565b606091505b509150915061069f8783838760608315611a8d5782515f03611a86576001600160a01b0385163b611a865760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161049f565b50816115d1565b6115d18383815115611aa25781518083602001fd5b8060405162461bcd60e51b815260040161049f9190611dab565b5f60208284031215611acc575f5ffd5b5035919050565b80356001600160a01b0381168114611ae9575f5ffd5b919050565b803563ffffffff81168114611ae9575f5ffd5b5f5f83601f840112611b11575f5ffd5b50813567ffffffffffffffff811115611b28575f5ffd5b6020830191508360208260051b8501011115611b42575f5ffd5b9250929050565b5f5f5f5f5f5f5f5f5f6101008a8c031215611b62575f5ffd5b89359850611b7260208b01611ad3565b9750611b8060408b01611aee565b965060608a013567ffffffffffffffff811115611b9b575f5ffd5b611ba78c828d01611b01565b90975095505060808a0135935060a08a013560ff81168114611bc7575f5ffd5b989b979a50959894979396929550929360c0810135935060e00135919050565b5f5f60408385031215611bf8575f5ffd5b50508035926020909101359150565b5f5f60408385031215611c18575f5ffd5b82359150611c2860208401611aee565b90509250929050565b5f5f5f5f5f60808688031215611c45575f5ffd5b85359450611c5560208701611ad3565b9350611c6360408701611aee565b9250606086013567ffffffffffffffff811115611c7e575f5ffd5b611c8a88828901611b01565b969995985093965092949392505050565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52601160045260245ffd5b80820281158282048414176105ab576105ab611caf565b808201808211156105ab576105ab611caf565b634e487b7160e01b5f52601260045260245ffd5b5f82611d1b57634e487b7160e01b5f52601260045260245ffd5b500490565b818103818111156105ab576105ab611caf565b5f60208284031215611d43575f5ffd5b5051919050565b5f60018201611d5b57611d5b611caf565b5060010190565b634e487b7160e01b5f52602160045260245ffd5b5f60208284031215611d86575f5ffd5b815180151581146118d5575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122097133a45860ac9deb240ba46946e0c78bc6d9791df9cf6a863cd490e428ae86264736f6c634300081e0033","sourceMap":"1875:17576:85:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2526:180;;;;;;:::i;:::-;;:::i;:::-;;;391:25:114;;;379:2;364:18;2526:180:85;;;;;;;;4096:36;;;;;18521:545;;;:::i;4138:31::-;;;;;;14538:544;;;;;;:::i;:::-;;:::i;16494:504::-;;;;;;:::i;:::-;;:::i;:::-;;9053:163;;;;;;:::i;:::-;;:::i;4175:29::-;;;;;;4211:52;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4211:52:85;;;;-1:-1:-1;;;4211:52:85;;;;;-1:-1:-1;;;4211:52:85;;;;;-1:-1:-1;;;4211:52:85;;;;;;;;;;2630:25:114;;;-1:-1:-1;;;;;2691:32:114;;;2686:2;2671:18;;2664:60;2772:10;2760:23;;;2740:18;;;2733:51;;;;2820:23;;2815:2;2800:18;;2793:51;2881:23;2875:3;2860:19;;2853:52;2617:3;2602:19;4211:52:85;2377:534:114;17842:581:85;;;;;;:::i;:::-;;:::i;17262:258::-;;;;;;:::i;:::-;;:::i;15408:801::-;;;;;;:::i;:::-;;:::i;4330:37::-;;;;;;:::i;:::-;;:::i;8667:163::-;;;;;;:::i;:::-;;:::i;19288:161::-;;;:::i;9834:4055::-;;;;;;:::i;:::-;;:::i;2526:180::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2526:180:85;:::o;18521:545::-;18694:16;;18573:22;;18694:20;18690:370;;18735:9;18730:136;18754:9;:16;18750:20;;18730:136;;;18828:20;18849:1;18828:23;;;;;;;;:::i;:::-;;;;;;;;;18813:9;18823:1;18813:12;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;:::i;:::-;18795:56;;;;:::i;:::-;;-1:-1:-1;18772:3:85;;18730:136;;;-1:-1:-1;18913:16:85;;18896:33;;:14;:33;:::i;:::-;19018:9;19028:16;;18879:50;;-1:-1:-1;19018:9:85;19028:20;;19018:9;;19028:20;:::i;:::-;19018:31;;;;;;;;:::i;:::-;;;;;;;;;18994:14;19011:4;18994:21;;;;:::i;:::-;:55;;;;:::i;:::-;18977:72;;18690:370;18521:545;:::o;14538:544::-;14918:88;;-1:-1:-1;;;14918:88:85;;-1:-1:-1;;;;;5656:32:114;;;14918:88:85;;;5638:51:114;14973:4:85;5705:18:114;;;5698:60;5774:18;;;5767:34;;;5817:18;;;5810:34;;;5893:4;5881:17;;5860:19;;;5853:46;5915:19;;;5908:35;;;5959:19;;;5952:35;;;14884:18:85;;14938:7;14918:36;;;;;;5610:19:114;;14918:88:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15023:52;15030:6;15038:8;15048:7;15057:17;;15023:6;:52::i;:::-;15016:59;14538:544;-1:-1:-1;;;;;;;;;;14538:544:85:o;16494:504::-;16555:27;16585:21;;;:9;:21;;;;;16620:9;;;;-1:-1:-1;;;;;16620:9:85;16633:10;16620:23;16616:96;;16691:9;;;;16666:35;;-1:-1:-1;;;16666:35:85;;16679:10;16666:35;;;6172:51:114;-1:-1:-1;;;;;16691:9:85;;;6239:18:114;;;6232:60;6145:18;;16666:35:85;;;;;;;;16616:96;16725:16;;;;-1:-1:-1;;;16725:16:85;;;;16745:1;16725:21;16721:99;;16769:40;;-1:-1:-1;;;16769:40:85;;;;;6477:25:114;;;16798:10:85;6518:18:114;;;6511:60;6450:18;;16769:40:85;6303:274:114;16721:99:85;16907:44;16915:10;16927:3;2318:16;16907:7;:44::i;:::-;16961:30;16975:10;16987:3;16961:13;:30::i;:::-;16545:453;16494:504;:::o;9053:163::-;9114:7;9140:69;9154:7;-1:-1:-1;;;;;9154:19:85;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9140:6;;9177:11;9190:18;9140:13;:69::i;:::-;9133:76;9053:163;-1:-1:-1;;9053:163:85:o;17842:581::-;17925:17;17984:21;;;:9;:21;;;;;18100:16;;;;17925:17;;18119:16;;18082:34;;-1:-1:-1;;;18100:16:85;;;;18082:15;:34;:::i;:::-;:53;18081:111;;18177:15;18081:111;;;18139:16;;;;:35;;18158:16;;-1:-1:-1;;;18139:16:85;;;;:35;:::i;:::-;18231:15;;;;18066:126;;-1:-1:-1;18202:19:85;;18224:22;;-1:-1:-1;;;18231:15:85;;;;18066:126;18224:22;:::i;:::-;18202:44;;18256:20;18279:25;18294:3;:9;;;18279:14;:25::i;:::-;18256:48;;2829:3;18381:18;18366:11;18341:9;18351:3;:11;;;;;;;;;;;;18341:22;;;;;;;;;;:::i;:::-;;;;;;;;;18326:12;:37;;;;:::i;:::-;:51;;;;:::i;:::-;:74;;;;:::i;:::-;:90;;;;:::i;:::-;18314:102;17842:581;-1:-1:-1;;;;;;;17842:581:85:o;17262:258::-;17317:27;17347:21;;;:9;:21;;;;;17382:16;;;;17347:21;;-1:-1:-1;;;17382:16:85;;;;;:21;;17378:99;;17426:40;;-1:-1:-1;;;17426:40:85;;;;;6477:25:114;;;17455:10:85;6518:18:114;;;6511:60;6450:18;;17426:40:85;6303:274:114;17378:99:85;17486:27;17494:10;17506:3;17511:1;17486:7;:27::i;15408:801::-;15500:9;:16;15490:26;;;;15482:61;;;;-1:-1:-1;;;15482:61:85;;6973:2:114;15482:61:85;;;6955:21:114;7012:2;6992:18;;;6985:30;-1:-1:-1;;;7031:18:114;;;7024:52;7093:18;;15482:61:85;6771:346:114;15482:61:85;15553:27;15583:21;;;:9;:21;;;;;15618:16;;;;15583:21;;-1:-1:-1;;;15618:16:85;;;;;:21;;15614:99;;15662:40;;-1:-1:-1;;;15662:40:85;;;;;6477:25:114;;;15691:10:85;6518:18:114;;;6511:60;6450:18;;15662:40:85;6303:274:114;15614:99:85;15726:9;;;;-1:-1:-1;;;;;15726:9:85;15739:10;15726:23;15722:96;;15797:9;;;;15772:35;;-1:-1:-1;;;15772:35:85;;15785:10;15772:35;;;6172:51:114;-1:-1:-1;;;;;15797:9:85;;;6239:18:114;;;6232:60;6145:18;;15772:35:85;5998:300:114;15722:96:85;15925:11;;;;;-1:-1:-1;;;15925:11:85;;;;;15915:21;;;;15907:55;;;;-1:-1:-1;;;15907:55:85;;7324:2:114;15907:55:85;;;7306:21:114;7363:2;7343:18;;;7336:30;-1:-1:-1;;;7382:18:114;;;7375:51;7443:18;;15907:55:85;7122:345:114;15907:55:85;15972:27;15980:10;15992:3;15997:1;15972:7;:27::i;:::-;16046:9;;16030:11;;;;16009:20;:33;;:20;;-1:-1:-1;;;16030:11:85;;;;;16009:33;;;;;;:::i;:::-;;;;;;;;;:46;;;;;;;:::i;:::-;;;;-1:-1:-1;;16098:9:85;;16065:20;:29;;;;;;;;;;;;:::i;:::-;;;;;;;;;:42;;;;;;;:::i;:::-;;;;-1:-1:-1;;16117:11:85;;;:21;;-1:-1:-1;;;;;16117:21:85;;-1:-1:-1;;;16117:21:85;;;;;;;;;;;;16153:49;;7617:42:114;;;-1:-1:-1;;;;;16183:9:85;;;;;;;16171:10;;16153:49;;7605:2:114;7590:18;16153:49:85;;;;;;;15472:737;15408:801;;:::o;4330:37::-;;;;;;;;;;;;8667:163;8728:7;8754:69;8768:11;8781:7;-1:-1:-1;;;;;8781:19:85;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8754:6;;:69;8804:18;8754:13;:69::i;19288:161::-;19342:24;19425:17;:15;:17::i;:::-;19398:16;;:23;;19417:4;19398:23;:::i;9834:4055::-;9954:18;10016:20;10039:22;10054:6;10039:14;:22::i;:::-;10016:45;;10220:16;10239:7;-1:-1:-1;;;;;10239:16:85;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10220:37;;10284:8;10275:6;:17;10271:102;;;10319:39;;-1:-1:-1;;;10319:39:85;;-1:-1:-1;;;;;7890:32:114;;10319:39:85;;;7872:51:114;7939:18;;;7932:34;;;7982:18;;;7975:34;;;7845:18;;10319:39:85;7670:345:114;10271:102:85;-1:-1:-1;10410:9:85;:16;10400:26;;;;10392:61;;;;-1:-1:-1;;;10392:61:85;;6973:2:114;10392:61:85;;;6955:21:114;7012:2;6992:18;;;6985:30;-1:-1:-1;;;7031:18:114;;;7024:52;7093:18;;10392:61:85;6771:346:114;10392:61:85;10562:16;;10496:11;;10464:29;;10542:17;:15;:17::i;:::-;:36;;;;:::i;:::-;10517:61;-1:-1:-1;10621:1:85;10593:29;;10589:888;;10703:9;10698:769;10722:28;10749:1;10722:17;:28;:::i;:::-;10718:1;:32;10698:769;;;10775:27;10805:9;:31;10815:17;;10833:1;10815:20;;;;;;;:::i;:::-;;;;;;;10805:31;;;;;;;;;;;10775:61;;10858:3;:16;;;;;;;;;;;;:21;;10878:1;10858:21;10854:123;;10927:17;;10945:1;10927:20;;;;;;;:::i;:::-;10910:48;;-1:-1:-1;;;10910:48:85;;10927:20;;;;;;;;;10910:48;;;6477:25:114;-1:-1:-1;;;;;;6538:32:114;;6518:18;;;6511:60;6450:18;;10910:48:85;6303:274:114;10854:123:85;11049:11;;;;;-1:-1:-1;;;11049:11:85;;;;;11038:22;;;;11034:139;;11120:11;;;;11101:8;;11111:7;;-1:-1:-1;;;11120:11:85;;;;11133:17;;11151:1;11133:20;;;;;;;:::i;:::-;11091:63;;-1:-1:-1;;;11091:63:85;;-1:-1:-1;;;;;8265:32:114;;;;11091:63:85;;;8247:51:114;8346:10;8334:23;;;8314:18;;;8307:51;8394:23;;;;8374:18;;;8367:51;11133:20:85;;;;;;8434:18:114;;;8427:34;-1:-1:-1;8219:19:114;;11091:63:85;8020:447:114;11034:139:85;11194:9;;:33;-1:-1:-1;11190:113:85;;;11275:9;;;-1:-1:-1;11190:113:85;11357:37;11365:17;;11383:1;11365:20;;;;;;;:::i;:::-;;;;;;;11387:3;11392:1;11357:7;:37::i;:::-;11412:40;11426:17;;11444:1;11426:20;;;;;;;:::i;:::-;;;;;;;11448:3;11412:13;:40::i;:::-;-1:-1:-1;10752:3:85;;10698:769;;;;10589:888;11523:16;;11503:17;:15;:17::i;:::-;:36;;;;:::i;:::-;11486:53;-1:-1:-1;11554:28:85;;11550:1294;;11659:13;11675:28;11702:1;11675:17;:28;:::i;:::-;11659:44;;11717:31;11751:9;:35;11761:17;;11779:5;11761:24;;;;;;;:::i;:::-;;;;;;;11751:35;;;;;;;;;;;11717:69;;11804:7;:20;;;;;;;;;;;;:25;;11828:1;11804:25;11800:123;;11873:17;;11891:5;11873:24;;;;;;;:::i;11800:123::-;11987:15;;;;;-1:-1:-1;;;11987:15:85;;;;;11976:26;;;;11972:143;;12058:15;;;;12039:8;;12049:7;;-1:-1:-1;;;12058:15:85;;;;12075:17;;12093:5;12075:24;;;;;;;:::i;11972:143::-;12132:13;;:37;-1:-1:-1;12128:113:85;;;12213:13;;;-1:-1:-1;12128:113:85;12287:62;12295:17;;12313:5;12295:24;;;;;;;:::i;:::-;;;;;;;12321:7;2318:16;12287:7;:62::i;:::-;12384:12;12367:14;:29;12363:151;;;12423:76;;-1:-1:-1;;;12423:76:85;;-1:-1:-1;;;;;8721:32:114;;12423:76:85;;;8703:51:114;8770:18;;;8763:34;;;8813:18;;;8806:34;;;8856:18;;;8849:34;;;8675:19;;12423:76:85;8472:417:114;12363:151:85;12527:24;12554:29;12569:14;12554:12;:29;:::i;:::-;12620:13;;12527:56;;-1:-1:-1;12641:3:85;;12620:18;;12636:2;12620:18;:::i;:::-;:24;;;;:::i;:::-;12601:16;:43;12597:237;;;12664:48;12678:17;;12696:5;12678:24;;;;;;;:::i;:::-;;;;;;;12704:7;12664:13;:48::i;:::-;12597:237;;;12751:68;12767:17;;12785:5;12767:24;;;;;;;:::i;:::-;;;;;;;12793:7;12802:16;12751:15;:68::i;:::-;11584:1260;;;11550:1294;12890:16;;12870:17;:15;:17::i;:::-;:36;;;;:::i;:::-;12853:53;;12936:14;12921:12;:29;12917:129;;;12973:62;;-1:-1:-1;;;12973:62:85;;-1:-1:-1;;;;;7890:32:114;;12973:62:85;;;7872:51:114;7939:18;;;7932:34;;;7982:18;;;7975:34;;;7845:18;;12973:62:85;7670:345:114;12917:129:85;13162:21;13130:29;13147:12;13130:14;:29;:::i;:::-;:53;13126:167;;;13206:76;;-1:-1:-1;;;13206:76:85;;-1:-1:-1;;;;;8721:32:114;;13206:76:85;;;8703:51:114;8770:18;;;8763:34;;;8813:18;;;8806:34;;;8856:18;;;8849:34;;;8675:19;;13206:76:85;8472:417:114;13126:167:85;13323:70;13350:7;13359:10;13379:4;13386:6;13323:26;:70::i;:::-;13433:14;:16;;;:14;:16;;;:::i;:::-;;;;;13420:29;;13459:26;13488:9;:21;13498:10;13488:21;;;;;;;;;;;13459:50;;13530:12;13519:2;:8;;:23;;;;13563:8;13552:2;:8;;;:19;;;;;-1:-1:-1;;;;;13552:19:85;;;;;-1:-1:-1;;;;;13552:19:85;;;;;;13605:15;13581:2;:14;;;:40;;;;;;;;;;;;;;;;;;13656:15;13631:2;:15;;;:41;;;;;;;;;;;;;;;;;;13695:7;13682:2;:10;;;:20;;;;;;;;;;;;;;;;;;13746:12;13713:20;13734:7;13713:29;;;;;;;;;;:::i;:::-;;;;;;;;;:45;;;;;;;:::i;:::-;;;;;;;;13788:12;13768:16;;:32;;;;;;;:::i;:::-;;;;-1:-1:-1;;13843:8:85;;;;13861;;13815:67;;;9234:25:114;;;9290:2;9275:18;;9268:34;;;;13871:10:85;-1:-1:-1;;;13871:10:85;;;9318:18:114;;;9311:51;-1:-1:-1;;;;;13843:8:85;;;;13831:10;;13815:67;;9222:2:114;9207:18;13815:67:85;;;;;;;9974:3915;;;;9834:4055;;;;;;;:::o;5339:1779::-;5592:16;;;;5558:12;;5611:16;;5574:34;;-1:-1:-1;;;5592:16:85;;;;5574:15;:34;:::i;:::-;:53;5573:111;;5669:15;5573:111;;;5631:16;;;;:35;;5650:16;;-1:-1:-1;;;5631:16:85;;;;:35;:::i;:::-;5723:15;;;;5558:126;;-1:-1:-1;5694:19:85;;5716:22;;-1:-1:-1;;;5723:15:85;;;;5558:126;5716:22;:::i;:::-;5694:44;;5748:20;5771:25;5786:3;:9;;;5771:14;:25::i;:::-;5748:48;;5806:20;2829:3;5884:18;5869:11;5844:9;5854:3;:11;;;;;;;;;;;;5844:22;;;;;;;;;;:::i;:::-;;;;;;;;;5829:12;:37;;;;:::i;:::-;:51;;;;:::i;:::-;:74;;;;:::i;:::-;:90;;;;:::i;:::-;5806:113;;5949:12;5933;:28;5929:145;;-1:-1:-1;6051:12:85;5929:145;6117:1;6087:27;6102:12;6087;:27;:::i;:::-;:31;6083:961;;;6188:21;6212:43;6227:27;6242:12;6227;:27;:::i;6212:43::-;6188:67;;6269:18;6302:13;6290:3;:9;;;:25;;;;:::i;:::-;6269:46;;6366:10;6329:20;6350:3;:11;;;;;;;;;;;;6329:33;;;;;;;;;;:::i;:::-;;;;;;;;;:47;;;;;;;:::i;:::-;;;;;;;;6410:10;6390:16;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;6434:25:85;;;6473:15;;;:41;;;6498:15;6473:41;;-1:-1:-1;;;6473:41:85;-1:-1:-1;;;;6473:41:85;;;;;;;;6533:80;;;9234:25:114;;;9290:2;9275:18;;9268:34;;;-1:-1:-1;;;6601:11:85;;;;;;9318:18:114;;;9311:51;;;;-1:-1:-1;;;;;6561:9:85;;;;;;;6549:10;;6533:80;;9222:2:114;9207:18;6533:80:85;;;;;;;6120:504;;6083:961;;;6737:9;;6721:11;;;;6700:20;:33;;:20;;-1:-1:-1;;;6721:11:85;;;;;6700:33;;;;;;:::i;:::-;;;;;;;;;:46;;;;;;;:::i;:::-;;;;-1:-1:-1;;6780:9:85;;6760:16;:29;;6780:9;;6760:29;;6780:9;;6760:29;:::i;:::-;;;;-1:-1:-1;;6836:9:85;;;;6808:68;;;9234:25:114;;;6836:9:85;9290:2:114;9275:18;;9268:34;6864:11:85;-1:-1:-1;;;6864:11:85;;;9318:18:114;;;9311:51;6808:68:85;;-1:-1:-1;;;;;6836:9:85;;;;6824:10;;6808:68;;;;;;9222:2:114;6808:68:85;;;6923:9;;;;6895:41;;6923:9;391:25:114;;-1:-1:-1;;;;;6923:9:85;;;;6911:10;;6895:41;;379:2:114;364:18;6895:41:85;;;;;;;6957:9;;;6950:16;;-1:-1:-1;;;;;;6980:23:85;;;6957:9;7017:16;;6083:961;7053:58;7076:7;7085:11;7098:12;7053:22;:58::i;:::-;5439:1679;;;;5339:1779;;;:::o;7263:467::-;7390:9;;7374:11;;;;7353:20;:33;;:20;;-1:-1:-1;;;7374:11:85;;;;;7353:33;;;;;;:::i;:::-;;;;;;;;;:46;;;;;;;:::i;:::-;;;;-1:-1:-1;;7429:9:85;;7409:16;:29;;7429:9;;7409:29;;7429:9;;7409:29;:::i;:::-;;;;-1:-1:-1;;7464:9:85;;;;7515;;-1:-1:-1;;;;;7464:9:85;;;;7448:13;;7500:25;;:14;:25::i;:::-;7483:42;;7568:5;-1:-1:-1;;;;;7540:42:85;7556:10;7540:42;7575:6;7540:42;;;;391:25:114;;379:2;364:18;;245:177;7540:42:85;;;;;;;;7599:9;;;7592:16;;-1:-1:-1;;;;;;7618:23:85;;;7599:9;7651:16;;7677:46;7700:7;7709:5;7716:6;7677:22;:46::i;:::-;7343:387;;7263:467;;:::o;6012:299:49:-;6113:7;6132:14;6149:25;6156:1;6159;6162:11;6149:6;:25::i;:::-;6132:42;-1:-1:-1;6200:11:49;6188:8;:23;;;;;;;;:::i;:::-;;:56;;;;;6243:1;6228:11;6215:25;;;;;:::i;:::-;6225:1;6222;6215:25;:29;6188:56;6184:98;;;6260:11;6270:1;6260:11;;:::i;:::-;;;6184:98;6298:6;-1:-1:-1;6012:299:49;;;;;;;:::o;5083:111:85:-;5132:7;5184:3;5158:23;2238:2;5158:11;:23;:::i;7901:498::-;8038:9;;8023:24;;8015:55;;;;-1:-1:-1;;;8015:55:85;;10585:2:114;8015:55:85;;;10567:21:114;10624:2;10604:18;;;10597:30;-1:-1:-1;;;10643:18:114;;;10636:48;10701:18;;8015:55:85;10383:342:114;8015:55:85;8080:14;8097:28;8112:12;8097:14;:28::i;:::-;8080:45;;8148:12;8135:3;:9;;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;8191:11:85;;;;8170:20;:33;;8207:12;;-1:-1:-1;;;8191:11:85;;;;;8170:33;;;;;;:::i;:::-;;;;;;;;;:49;;;;;;;:::i;:::-;;;;;;;;8249:12;8229:16;;:32;;;;;;;:::i;:::-;;;;-1:-1:-1;;8303:9:85;;;;8314;;8276:56;;;10904:25:114;;;10960:2;10945:18;;10938:34;;;-1:-1:-1;;;;;8303:9:85;;;;8291:10;;8276:56;;10877:18:114;8276:56:85;;;;;;;8374:9;;;;8342:50;;8365:7;;-1:-1:-1;;;;;8374:9:85;8385:6;8342:22;:50::i;1355:203:40:-;1482:68;;-1:-1:-1;;;;;11203:32:114;;;1482:68:40;;;11185:51:114;11272:32;;11252:18;;;11245:60;11321:18;;;11314:34;;;1455:96:40;;1475:5;;-1:-1:-1;;;1505:27:40;11158:18:114;;1482:68:40;;;;-1:-1:-1;;1482:68:40;;;;;;;;;;;;;;-1:-1:-1;;;;;1482:68:40;-1:-1:-1;;;;;;1482:68:40;;;;;;;;;;1455:19;:96::i;941:175::-;1050:58;;-1:-1:-1;;;;;11551:32:114;;1050:58:40;;;11533:51:114;11600:18;;;11593:34;;;1023:86:40;;1043:5;;-1:-1:-1;;;1073:23:40;11506:18:114;;1050:58:40;11359:274:114;1023:86:40;941:175;;;:::o;1667:4213:49:-;1749:14;;;-1:-1:-1;;2286:1:49;2283;2276:20;2329:1;2326;2322:9;2313:18;;2384:5;2380:2;2377:13;2369:5;2365:2;2361:14;2357:34;2348:43;;;2486:5;2495:1;2486:10;2482:368;;2824:11;2816:5;:19;;;;;:::i;:::-;;2809:26;;;;;;2482:368;2974:5;2960:11;:19;2952:53;;;;-1:-1:-1;;;2952:53:49;;11840:2:114;2952:53:49;;;11822:21:114;11879:2;11859:18;;;11852:30;-1:-1:-1;;;11898:18:114;;;11891:51;11959:18;;2952:53:49;11638:345:114;2952:53:49;3261:17;3396:11;3393:1;3390;3383:25;3929:12;;3944:1;3929:16;;;3914:32;;4049:22;;;;;3557:21;;;4147:16;;;3510:20;;;;3499:32;;;3899:12;4294;;;4290:23;;;;4286:31;;;4406:12;;;;4397:21;;;;4755:1;:15;;4774:1;4754:21;;;5007;;;5003:25;;4992:36;5076:21;;;5072:25;;5061:36;5146:21;;;5142:25;;5131:36;5216:21;;;5212:25;;5201:36;5286:21;;;5282:25;;5271:36;5357:21;;;5353:25;;;5342:36;5821:15;;-1:-1:-1;;1667:4213:49;;;;;;:::o;5196:642:40:-;5615:23;5641:69;5669:4;5641:69;;;;;;;;;;;;;;;;;5649:5;-1:-1:-1;;;;;5641:27:40;;;:69;;;;;:::i;:::-;5615:95;;5728:10;:17;5749:1;5728:22;:56;;;;5765:10;5754:30;;;;;;;;;;;;:::i;:::-;5720:111;;;;-1:-1:-1;;;5720:111:40;;12472:2:114;5720:111:40;;;12454:21:114;12511:2;12491:18;;;12484:30;12550:34;12530:18;;;12523:62;-1:-1:-1;;;12601:18:114;;;12594:40;12651:19;;5720:111:40;12270:406:114;4108:223:41;4241:12;4272:52;4294:6;4302:4;4308:1;4311:12;4241;5446;5460:23;5487:6;-1:-1:-1;;;;;5487:11:41;5506:5;5513:4;5487:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5445:73;;;;5535:69;5562:6;5570:7;5579:10;5591:12;7851;7879:7;7875:418;;;7906:10;:17;7927:1;7906:22;7902:286;;-1:-1:-1;;;;;1702:19:41;;;8113:60;;;;-1:-1:-1;;;8113:60:41;;13596:2:114;8113:60:41;;;13578:21:114;13635:2;13615:18;;;13608:30;13674:31;13654:18;;;13647:59;13723:18;;8113:60:41;13394:353:114;8113:60:41;-1:-1:-1;8208:10:41;8201:17;;7875:418;8249:33;8257:10;8269:12;8980:17;;:21;8976:379;;9208:10;9202:17;9264:15;9251:10;9247:2;9243:19;9236:44;8976:379;9331:12;9324:20;;-1:-1:-1;;;9324:20:41;;;;;;;;:::i;14:226:114:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;187:23:114;;14:226;-1:-1:-1;14:226:114:o;427:173::-;495:20;;-1:-1:-1;;;;;544:31:114;;534:42;;524:70;;590:1;587;580:12;524:70;427:173;;;:::o;605:163::-;672:20;;732:10;721:22;;711:33;;701:61;;758:1;755;748:12;773:367;836:8;846:6;900:3;893:4;885:6;881:17;877:27;867:55;;918:1;915;908:12;867:55;-1:-1:-1;941:20:114;;984:18;973:30;;970:50;;;1016:1;1013;1006:12;970:50;1053:4;1045:6;1041:17;1029:29;;1113:3;1106:4;1096:6;1093:1;1089:14;1081:6;1077:27;1073:38;1070:47;1067:67;;;1130:1;1127;1120:12;1067:67;773:367;;;;;:::o;1145:1227::-;1291:6;1299;1307;1315;1323;1331;1339;1347;1355;1408:3;1396:9;1387:7;1383:23;1379:33;1376:53;;;1425:1;1422;1415:12;1376:53;1470:23;;;-1:-1:-1;1536:38:114;1570:2;1555:18;;1536:38;:::i;:::-;1526:48;;1593:37;1626:2;1615:9;1611:18;1593:37;:::i;:::-;1583:47;;1681:2;1670:9;1666:18;1653:32;1708:18;1700:6;1697:30;1694:50;;;1740:1;1737;1730:12;1694:50;1779:70;1841:7;1832:6;1821:9;1817:22;1779:70;:::i;:::-;1868:8;;-1:-1:-1;1753:96:114;-1:-1:-1;;1976:3:114;1961:19;;1948:33;;-1:-1:-1;2059:3:114;2044:19;;2031:33;2108:4;2095:18;;2083:31;;2073:59;;2128:1;2125;2118:12;2073:59;1145:1227;;;;-1:-1:-1;1145:1227:114;;;;;;;;-1:-1:-1;2151:7:114;;2231:3;2216:19;;2203:33;;-1:-1:-1;2335:3:114;2320:19;2307:33;;1145:1227;-1:-1:-1;1145:1227:114:o;2916:346::-;2984:6;2992;3045:2;3033:9;3024:7;3020:23;3016:32;3013:52;;;3061:1;3058;3051:12;3013:52;-1:-1:-1;;3106:23:114;;;3226:2;3211:18;;;3198:32;;-1:-1:-1;2916:346:114:o;3267:298::-;3334:6;3342;3395:2;3383:9;3374:7;3370:23;3366:32;3363:52;;;3411:1;3408;3401:12;3363:52;3456:23;;;-1:-1:-1;3522:37:114;3555:2;3540:18;;3522:37;:::i;:::-;3512:47;;3267:298;;;;;:::o;3570:698::-;3682:6;3690;3698;3706;3714;3767:3;3755:9;3746:7;3742:23;3738:33;3735:53;;;3784:1;3781;3774:12;3735:53;3829:23;;;-1:-1:-1;3895:38:114;3929:2;3914:18;;3895:38;:::i;:::-;3885:48;;3952:37;3985:2;3974:9;3970:18;3952:37;:::i;:::-;3942:47;;4040:2;4029:9;4025:18;4012:32;4067:18;4059:6;4056:30;4053:50;;;4099:1;4096;4089:12;4053:50;4138:70;4200:7;4191:6;4180:9;4176:22;4138:70;:::i;:::-;3570:698;;;;-1:-1:-1;3570:698:114;;-1:-1:-1;4227:8:114;;4112:96;3570:698;-1:-1:-1;;;3570:698:114:o;4273:127::-;4334:10;4329:3;4325:20;4322:1;4315:31;4365:4;4362:1;4355:15;4389:4;4386:1;4379:15;4405:127;4466:10;4461:3;4457:20;4454:1;4447:31;4497:4;4494:1;4487:15;4521:4;4518:1;4511:15;4537:168;4610:9;;;4641;;4658:15;;;4652:22;;4638:37;4628:71;;4679:18;;:::i;4710:125::-;4775:9;;;4796:10;;;4793:36;;;4809:18;;:::i;4840:127::-;4901:10;4896:3;4892:20;4889:1;4882:31;4932:4;4929:1;4922:15;4956:4;4953:1;4946:15;4972:217;5012:1;5038;5028:132;;5082:10;5077:3;5073:20;5070:1;5063:31;5117:4;5114:1;5107:15;5145:4;5142:1;5135:15;5028:132;-1:-1:-1;5174:9:114;;4972:217::o;5194:128::-;5261:9;;;5282:11;;;5279:37;;;5296:18;;:::i;6582:184::-;6652:6;6705:2;6693:9;6684:7;6680:23;6676:32;6673:52;;;6721:1;6718;6711:12;6673:52;-1:-1:-1;6744:16:114;;6582:184;-1:-1:-1;6582:184:114:o;8894:135::-;8933:3;8954:17;;;8951:43;;8974:18;;:::i;:::-;-1:-1:-1;9021:1:114;9010:13;;8894:135::o;10251:127::-;10312:10;10307:3;10303:20;10300:1;10293:31;10343:4;10340:1;10333:15;10367:4;10364:1;10357:15;11988:277;12055:6;12108:2;12096:9;12087:7;12083:23;12079:32;12076:52;;;12124:1;12121;12114:12;12076:52;12156:9;12150:16;12209:5;12202:13;12195:21;12188:5;12185:32;12175:60;;12231:1;12228;12221:12;13088:301;13217:3;13255:6;13249:13;13301:6;13294:4;13286:6;13282:17;13277:3;13271:37;13363:1;13327:16;;13352:13;;;-1:-1:-1;13327:16:114;13088:301;-1:-1:-1;13088:301:114:o;13752:418::-;13901:2;13890:9;13883:21;13864:4;13933:6;13927:13;13976:6;13971:2;13960:9;13956:18;13949:34;14035:6;14030:2;14022:6;14018:15;14013:2;14002:9;13998:18;13992:50;14091:1;14086:2;14077:6;14066:9;14062:22;14058:31;14051:42;14161:2;14154;14150:7;14145:2;14137:6;14133:15;14129:29;14118:9;14114:45;14110:54;14102:62;;;13752:418;;;;:::o","linkReferences":{},"immutableReferences":{"62218":[{"start":990,"length":32},{"start":1284,"length":32},{"start":2403,"length":32},{"start":2584,"length":32},{"start":3928,"length":32},{"start":5159,"length":32},{"start":5456,"length":32},{"start":5922,"length":32}],"62220":[{"start":5192,"length":32}],"62222":[{"start":298,"length":32},{"start":1414,"length":32},{"start":2370,"length":32},{"start":2856,"length":32},{"start":5603,"length":32}]}},"methodIdentifiers":{"TAX_RATES(uint256)":"13f5c726","assetsToShares(uint256)":"e0b231fa","changeTax(uint256,uint32)":"b8b1bc51","exitPosition(uint256)":"78dc9059","getAverageTaxRate()":"21139a01","getPercentageStaked()":"e95beb93","nextPositionId()":"899346c7","outstandingStake()":"53432750","payTax(uint256)":"a05aaf50","permitAndSnatch(uint256,address,uint32,uint256[],uint256,uint8,bytes32,bytes32)":"5cb36034","positions(uint256)":"99fbab88","sharesToAssets(uint256)":"7fe0c850","snatch(uint256,address,uint32,uint256[])":"febf6b7b","taxDue(uint256,uint256)":"9d8e5ea7","totalSharesAtTaxRate(uint256)":"cbcebdba","totalSupply()":"18160ddd"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_kraiken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_taxReceiver\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"stakeWanted\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"availableStake\",\"type\":\"uint256\"}],\"name\":\"ExceededAvailableStake\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"requester\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NoPermission\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requester\",\"type\":\"address\"}],\"name\":\"PositionNotFound\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minStake\",\"type\":\"uint256\"}],\"name\":\"StakeTooLow\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"taxRateWanted\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"taxRateMet\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"}],\"name\":\"TaxTooLow\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"stakeWanted\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"availableStake\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"smallestShare\",\"type\":\"uint256\"}],\"name\":\"TooMuchSnatch\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"kraikenDeposit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"share\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"taxRate\",\"type\":\"uint32\"}],\"name\":\"PositionCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newTaxRate\",\"type\":\"uint256\"}],\"name\":\"PositionRateHiked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"kraikenPayout\",\"type\":\"uint256\"}],\"name\":\"PositionRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newShares\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"kraikenPayout\",\"type\":\"uint256\"}],\"name\":\"PositionShrunk\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"taxPaid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newShares\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"taxRate\",\"type\":\"uint256\"}],\"name\":\"PositionTaxPaid\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"TAX_RATES\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"}],\"name\":\"assetsToShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"taxRate\",\"type\":\"uint32\"}],\"name\":\"changeTax\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"}],\"name\":\"exitPosition\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getAverageTaxRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"averageTaxRate\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPercentageStaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"percentageStaked\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextPositionId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"outstandingStake\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"}],\"name\":\"payTax\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"taxRate\",\"type\":\"uint32\"},{\"internalType\":\"uint256[]\",\"name\":\"positionsToSnatch\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permitAndSnatch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"positions\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"share\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"creationTime\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"lastTaxTime\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"taxRate\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"sharesToAssets\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"taxRate\",\"type\":\"uint32\"},{\"internalType\":\"uint256[]\",\"name\":\"positionsToSnatch\",\"type\":\"uint256[]\"}],\"name\":\"snatch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"positionId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"taxFloorDuration\",\"type\":\"uint256\"}],\"name\":\"taxDue\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountDue\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"totalSharesAtTaxRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Self-assessed tax implementation:      - Continuous auction mechanism      - Self-assessed valuations create prediction market      - Tax collection and redistribution through UBI\",\"errors\":{\"TaxTooLow(address,uint64,uint64,uint256)\":[{\"details\":\"Attempted to deposit more assets than the max amount for `receiver`.\"}]},\"kind\":\"dev\",\"methods\":{\"assetsToShares(uint256)\":{\"params\":{\"assets\":\"Number of Kraiken tokens to convert.\"},\"returns\":{\"_0\":\"Number of shares corresponding to the input assets based on the current total supply of Kraiken tokens.\"}},\"changeTax(uint256,uint32)\":{\"details\":\"Ensures that the tax rate change is valid and applies the minimum tax based on the TAX_FLOOR_DURATION.\",\"params\":{\"positionId\":\"The ID of the staking position to update.\",\"taxRate\":\"The new tax rate to apply to the position.\"}},\"constructor\":{\"details\":\"Sets up the total supply based on the decimals of the Kraiken token plus a fixed offset.\",\"params\":{\"_kraiken\":\"Address of the Kraiken contract which this Stake contract interacts with.\"}},\"exitPosition(uint256)\":{\"details\":\"Pays the due taxes based on the TAX_FLOOR_DURATION and returns the remaining assets to the position owner.\",\"params\":{\"positionId\":\"The ID of the staking position to exit.\"}},\"getAverageTaxRate()\":{\"returns\":{\"averageTaxRate\":\"A number between 0 and 1e18 indicating the average tax rate.\"}},\"getPercentageStaked()\":{\"returns\":{\"percentageStaked\":\"A number between 0 and 1e18 indicating the percentage of Kraiken supply staked.\"}},\"payTax(uint256)\":{\"details\":\"Calculates and pays the tax due, possibly adjusting the position's share count.\",\"params\":{\"positionId\":\"The ID of the staking position for which to pay taxes.\"}},\"permitAndSnatch(uint256,address,uint32,uint256[],uint256,uint8,bytes32,bytes32)\":{\"params\":{\"assets\":\"Number of Kraiken tokens to stake.\",\"deadline\":\"Time until which the permit is valid.\",\"positionsToSnatch\":\"Array of position IDs that the new position will replace by snatching.\",\"receiver\":\"Address that will own the new staking position.\",\"taxRate\":\"The initial tax rate for the new staking position.\",\"v\":\", r, s Components of the signature for the permit.\"},\"returns\":{\"positionId\":\"The ID of the newly created staking position.\"}},\"sharesToAssets(uint256)\":{\"params\":{\"shares\":\"Number of shares to convert.\"},\"returns\":{\"_0\":\"The equivalent number of Kraiken tokens for the given shares.\"}},\"snatch(uint256,address,uint32,uint256[])\":{\"details\":\"Handles staking logic, including tax rate validation and position merging or dissolving.\",\"params\":{\"assets\":\"Amount of Kraiken tokens to convert into a staking position.\",\"positionsToSnatch\":\"Array of position IDs that the new position will replace by snatching.\",\"receiver\":\"Address that will own the new staking position.\",\"taxRate\":\"The initial tax rate for the new staking position.\"},\"returns\":{\"positionId\":\"The ID of the newly created staking position.\"}},\"taxDue(uint256,uint256)\":{\"details\":\"Calculates the tax due.\",\"params\":{\"positionId\":\"The ID of the staking position for which to pay taxes.\",\"taxFloorDuration\":\"if a minimum holding duration is applied to the position this value is > 0 in seconds.\"}}},\"title\":\"Stake Contract for Kraiken Token\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"assetsToShares(uint256)\":{\"notice\":\"Converts Kraiken token assets to shares of the total staking pool.\"},\"changeTax(uint256,uint32)\":{\"notice\":\"Changes the tax rate of an existing staking position.\"},\"constructor\":{\"notice\":\"Initializes the stake contract with references to the Kraiken contract and sets the initial position ID.\"},\"exitPosition(uint256)\":{\"notice\":\"Allows the owner of a staking position to exit, returning the staked assets.\"},\"getPercentageStaked()\":{\"notice\":\"Computes the percentage of Kraiken staked from outstanding Stake and authorized Stake.\"},\"payTax(uint256)\":{\"notice\":\"Manually triggers the tax payment for a specified staking position.\"},\"permitAndSnatch(uint256,address,uint32,uint256[],uint256,uint8,bytes32,bytes32)\":{\"notice\":\"Combines an ERC20 permit operation with the snatch function, allowing a staking position creation in one transaction.\"},\"sharesToAssets(uint256)\":{\"notice\":\"Converts shares of the total staking pool back to Kraiken token assets.\"},\"snatch(uint256,address,uint32,uint256[])\":{\"notice\":\"Creates a new staking position by potentially snatching shares from existing positions.\"},\"taxDue(uint256,uint256)\":{\"notice\":\"Calculates the Tax that is due to be paid on specific positoin\"}},\"notice\":\"This contract manages the staking positions for the Kraiken token, allowing users to stake tokens         in exchange for a share of the total supply. Stakers can set and adjust tax rates on their stakes,         which affect the Universal Basic Income (UBI) paid from the tax pool.         The contract handles:         - Creation of staking positions with specific tax rates.         - Snatching of existing positions under certain conditions to consolidate stakes.         - Calculation and payment of taxes based on stake duration and tax rate.         - Adjustment of tax rates with protections against griefing through rapid changes.         - Exiting of positions, either partially or fully, returning the staked assets to the owner.         Tax rates and staking positions are adjustable, with a mechanism to prevent snatch-grieving by         enforcing a minimum tax payment duration.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/Stake.sol\":\"Stake\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@aperture/uni-v3-lib/=lib/uni-v3-lib/src/\",\":@openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":@uniswap-v3-core/=lib/uni-v3-lib/node_modules/@uniswap/v3-core/contracts/\",\":@uniswap-v3-periphery/=lib/uni-v3-lib/node_modules/@uniswap/v3-periphery/contracts/\",\":@uniswap/=lib/uni-v3-lib/node_modules/@uniswap/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":base64-sol/=lib/uni-v3-lib/node_modules/base64-sol/\",\":ds-test/=lib/solmate/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":pt-v5-twab-controller/=lib/pt-v5-twab-controller/src/\",\":ring-buffer-lib/=lib/pt-v5-twab-controller/lib/ring-buffer-lib/src/\",\":solady/=lib/uni-v3-lib/node_modules/solady/\",\":solmate/=lib/solmate/src/\",\":uni-v3-lib/=lib/uni-v3-lib/src/\"]},\"sources\":{\"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol\":{\"keccak256\":\"0xac6c2efc64baccbde4904ae18ed45139c9aa8cff96d6888344d1e4d2eb8b659f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6e416a280c610b6b7a5f158e4a41aacfaec01ef14d5d1de13b46be9e090265fc\",\"dweb:/ipfs/QmYZP2KrdyccBbhLZT42auhvBTMkwiwUS3V6HWb42rbwbG\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15\",\"dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5\",\"dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Permit.sol\":{\"keccak256\":\"0xbb16110ffe0b625944fe7dd97adcf1158e514185c956a5628bc09be90d606174\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b5b412e554a4dd37a50f89ffcd7b9a6ef2ae5064f37619f89343b23d58ce89ca\",\"dweb:/ipfs/QmPWMdBvdFk8WBVv625wd1Ar7aehnBWtj1XfFRrRL5KpxJ\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd\",\"dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"keccak256\":\"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://28879d01fd22c07b44f006612775f8577defbe459cb01685c5e25cd518c91a71\",\"dweb:/ipfs/QmVgfkwv2Fxw6hhTcDUZhE7NkoSKjab3ipM7UaRbt6uXb5\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9d213d3befca47da33f6db0310826bcdb148299805c10d77175ecfe1d06a9a68\",\"dweb:/ipfs/QmRgCn6SP1hbBkExUADFuDo8xkT4UU47yjNF5FhCeRbQmS\"]},\"lib/openzeppelin-contracts/contracts/utils/Address.sol\":{\"keccak256\":\"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2455248c8ddd9cc6a7af76a13973cddf222072427e7b0e2a7d1aff345145e931\",\"dweb:/ipfs/QmfYjnjRbWqYpuxurqveE6HtzsY1Xx323J428AKQgtBJZm\"]},\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c\",\"dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h\"]},\"lib/openzeppelin-contracts/contracts/utils/Counters.sol\":{\"keccak256\":\"0xf0018c2440fbe238dd3a8732fa8e17a0f9dce84d31451dc8a32f6d62b349c9f1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://59e1c62884d55b70f3ae5432b44bb3166ad71ae3acd19c57ab6ddc3c87c325ee\",\"dweb:/ipfs/QmezuXg5GK5oeA4F91EZhozBFekhq5TD966bHPH18cCqhu\"]},\"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol\":{\"keccak256\":\"0xc0e310c163edf15db45d4ff938113ab357f94fa86e61ea8e790853c4d2e13256\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://04db5bc05dcb05ba1f6ca2dfbead17adc8a2e2f911aa80b05e7a36d9eaf96516\",\"dweb:/ipfs/QmVkfHZbXVBUPsTopueCn3qGJX8aEjahFF3Fn4NcygLNm5\"]},\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xf09e68aa0dc6722a25bc46490e8d48ed864466d17313b8a0b254c36b54e49899\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e26daf81e2252dc1fe1ce0e4b55c2eb7c6d1ee84ae6558d1a9554432ea1d32da\",\"dweb:/ipfs/Qmb1UANWiWq5pCKbmHSu772hd4nt374dVaghGmwSVNuk8Q\"]},\"lib/openzeppelin-contracts/contracts/utils/Strings.sol\":{\"keccak256\":\"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f\",\"dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x809bc3edb4bcbef8263fa616c1b60ee0004b50a8a1bfa164d8f57fd31f520c58\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8b93a1e39a4a19eba1600b92c96f435442db88cac91e315c8291547a2a7bcfe2\",\"dweb:/ipfs/QmTm34KVe6uZBZwq8dZDNWwPcm24qBJdxqL3rPxBJ4LrMv\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol\":{\"keccak256\":\"0x8432884527a7ad91e6eed1cfc5a0811ae2073e5bca107bd0ca442e9236b03dbd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e3aa0eadab7aafcf91a95684765f778f64386f0368de88522ce873c21385278a\",\"dweb:/ipfs/QmPfaVAqWgH1QsT3dHVuL6jwMZbVKdoP8w1PvpiPT2FPWd\"]},\"lib/openzeppelin-contracts/contracts/utils/math/Math.sol\":{\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c\",\"dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS\"]},\"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7\",\"dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6\"]},\"src/Kraiken.sol\":{\"keccak256\":\"0x1c942bc6eacd6f413c7e58e5d313e0a0b6ec642b4fcf28aedc7990f35df1d291\",\"license\":\"GPL-3.0-or-later\",\"urls\":[\"bzz-raw://8ba5284cf487489f6e33015ffcabafed502462e6ec27683e782066cc98cf861f\",\"dweb:/ipfs/Qme8uPk4hQPNDqMYG2NVxhwpCuq2a32mQbsTk4sdHPPhjx\"]},\"src/Stake.sol\":{\"keccak256\":\"0x64c687de1691b550bf533c9c5a9b5774b2127fe7ba94872230b489d751d113f3\",\"license\":\"GPL-3.0-or-later\",\"urls\":[\"bzz-raw://66bb7c21be51cfe5b3066e2589df41b5fb14e635398fe9055799e0d6aa251e1a\",\"dweb:/ipfs/QmVB3vnYz9HqgKXZgMXTqJA5ZqadF83mGyRUCgdRTcRhEB\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_kraiken","type":"address"},{"internalType":"address","name":"_taxReceiver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"stakeWanted","type":"uint256"},{"internalType":"uint256","name":"availableStake","type":"uint256"}],"type":"error","name":"ExceededAvailableStake"},{"inputs":[{"internalType":"address","name":"requester","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"type":"error","name":"NoPermission"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"},{"internalType":"address","name":"requester","type":"address"}],"type":"error","name":"PositionNotFound"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"minStake","type":"uint256"}],"type":"error","name":"StakeTooLow"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint64","name":"taxRateWanted","type":"uint64"},{"internalType":"uint64","name":"taxRateMet","type":"uint64"},{"internalType":"uint256","name":"positionId","type":"uint256"}],"type":"error","name":"TaxTooLow"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"stakeWanted","type":"uint256"},{"internalType":"uint256","name":"availableStake","type":"uint256"},{"internalType":"uint256","name":"smallestShare","type":"uint256"}],"type":"error","name":"TooMuchSnatch"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256","indexed":true},{"internalType":"address","name":"owner","type":"address","indexed":true},{"internalType":"uint256","name":"kraikenDeposit","type":"uint256","indexed":false},{"internalType":"uint256","name":"share","type":"uint256","indexed":false},{"internalType":"uint32","name":"taxRate","type":"uint32","indexed":false}],"type":"event","name":"PositionCreated","anonymous":false},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256","indexed":true},{"internalType":"address","name":"owner","type":"address","indexed":true},{"internalType":"uint256","name":"newTaxRate","type":"uint256","indexed":false}],"type":"event","name":"PositionRateHiked","anonymous":false},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256","indexed":true},{"internalType":"address","name":"owner","type":"address","indexed":true},{"internalType":"uint256","name":"kraikenPayout","type":"uint256","indexed":false}],"type":"event","name":"PositionRemoved","anonymous":false},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256","indexed":true},{"internalType":"address","name":"owner","type":"address","indexed":true},{"internalType":"uint256","name":"newShares","type":"uint256","indexed":false},{"internalType":"uint256","name":"kraikenPayout","type":"uint256","indexed":false}],"type":"event","name":"PositionShrunk","anonymous":false},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256","indexed":true},{"internalType":"address","name":"owner","type":"address","indexed":true},{"internalType":"uint256","name":"taxPaid","type":"uint256","indexed":false},{"internalType":"uint256","name":"newShares","type":"uint256","indexed":false},{"internalType":"uint256","name":"taxRate","type":"uint256","indexed":false}],"type":"event","name":"PositionTaxPaid","anonymous":false},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"TAX_RATES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function","name":"assetsToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"},{"internalType":"uint32","name":"taxRate","type":"uint32"}],"stateMutability":"nonpayable","type":"function","name":"changeTax"},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"exitPosition"},{"inputs":[],"stateMutability":"view","type":"function","name":"getAverageTaxRate","outputs":[{"internalType":"uint256","name":"averageTaxRate","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"getPercentageStaked","outputs":[{"internalType":"uint256","name":"percentageStaked","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"nextPositionId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"outstandingStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"payTax"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint32","name":"taxRate","type":"uint32"},{"internalType":"uint256[]","name":"positionsToSnatch","type":"uint256[]"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"stateMutability":"nonpayable","type":"function","name":"permitAndSnatch","outputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"positions","outputs":[{"internalType":"uint256","name":"share","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint32","name":"creationTime","type":"uint32"},{"internalType":"uint32","name":"lastTaxTime","type":"uint32"},{"internalType":"uint32","name":"taxRate","type":"uint32"}]},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function","name":"sharesToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint32","name":"taxRate","type":"uint32"},{"internalType":"uint256[]","name":"positionsToSnatch","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function","name":"snatch","outputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"positionId","type":"uint256"},{"internalType":"uint256","name":"taxFloorDuration","type":"uint256"}],"stateMutability":"view","type":"function","name":"taxDue","outputs":[{"internalType":"uint256","name":"amountDue","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"totalSharesAtTaxRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{"assetsToShares(uint256)":{"params":{"assets":"Number of Kraiken tokens to convert."},"returns":{"_0":"Number of shares corresponding to the input assets based on the current total supply of Kraiken tokens."}},"changeTax(uint256,uint32)":{"details":"Ensures that the tax rate change is valid and applies the minimum tax based on the TAX_FLOOR_DURATION.","params":{"positionId":"The ID of the staking position to update.","taxRate":"The new tax rate to apply to the position."}},"constructor":{"details":"Sets up the total supply based on the decimals of the Kraiken token plus a fixed offset.","params":{"_kraiken":"Address of the Kraiken contract which this Stake contract interacts with."}},"exitPosition(uint256)":{"details":"Pays the due taxes based on the TAX_FLOOR_DURATION and returns the remaining assets to the position owner.","params":{"positionId":"The ID of the staking position to exit."}},"getAverageTaxRate()":{"returns":{"averageTaxRate":"A number between 0 and 1e18 indicating the average tax rate."}},"getPercentageStaked()":{"returns":{"percentageStaked":"A number between 0 and 1e18 indicating the percentage of Kraiken supply staked."}},"payTax(uint256)":{"details":"Calculates and pays the tax due, possibly adjusting the position's share count.","params":{"positionId":"The ID of the staking position for which to pay taxes."}},"permitAndSnatch(uint256,address,uint32,uint256[],uint256,uint8,bytes32,bytes32)":{"params":{"assets":"Number of Kraiken tokens to stake.","deadline":"Time until which the permit is valid.","positionsToSnatch":"Array of position IDs that the new position will replace by snatching.","receiver":"Address that will own the new staking position.","taxRate":"The initial tax rate for the new staking position.","v":", r, s Components of the signature for the permit."},"returns":{"positionId":"The ID of the newly created staking position."}},"sharesToAssets(uint256)":{"params":{"shares":"Number of shares to convert."},"returns":{"_0":"The equivalent number of Kraiken tokens for the given shares."}},"snatch(uint256,address,uint32,uint256[])":{"details":"Handles staking logic, including tax rate validation and position merging or dissolving.","params":{"assets":"Amount of Kraiken tokens to convert into a staking position.","positionsToSnatch":"Array of position IDs that the new position will replace by snatching.","receiver":"Address that will own the new staking position.","taxRate":"The initial tax rate for the new staking position."},"returns":{"positionId":"The ID of the newly created staking position."}},"taxDue(uint256,uint256)":{"details":"Calculates the tax due.","params":{"positionId":"The ID of the staking position for which to pay taxes.","taxFloorDuration":"if a minimum holding duration is applied to the position this value is > 0 in seconds."}}},"version":1},"userdoc":{"kind":"user","methods":{"assetsToShares(uint256)":{"notice":"Converts Kraiken token assets to shares of the total staking pool."},"changeTax(uint256,uint32)":{"notice":"Changes the tax rate of an existing staking position."},"constructor":{"notice":"Initializes the stake contract with references to the Kraiken contract and sets the initial position ID."},"exitPosition(uint256)":{"notice":"Allows the owner of a staking position to exit, returning the staked assets."},"getPercentageStaked()":{"notice":"Computes the percentage of Kraiken staked from outstanding Stake and authorized Stake."},"payTax(uint256)":{"notice":"Manually triggers the tax payment for a specified staking position."},"permitAndSnatch(uint256,address,uint32,uint256[],uint256,uint8,bytes32,bytes32)":{"notice":"Combines an ERC20 permit operation with the snatch function, allowing a staking position creation in one transaction."},"sharesToAssets(uint256)":{"notice":"Converts shares of the total staking pool back to Kraiken token assets."},"snatch(uint256,address,uint32,uint256[])":{"notice":"Creates a new staking position by potentially snatching shares from existing positions."},"taxDue(uint256,uint256)":{"notice":"Calculates the Tax that is due to be paid on specific positoin"}},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@aperture/uni-v3-lib/=lib/uni-v3-lib/src/","@openzeppelin/=lib/openzeppelin-contracts/contracts/","@uniswap-v3-core/=lib/uni-v3-lib/node_modules/@uniswap/v3-core/contracts/","@uniswap-v3-periphery/=lib/uni-v3-lib/node_modules/@uniswap/v3-periphery/contracts/","@uniswap/=lib/uni-v3-lib/node_modules/@uniswap/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","base64-sol/=lib/uni-v3-lib/node_modules/base64-sol/","ds-test/=lib/solmate/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/","openzeppelin/=lib/openzeppelin-contracts/contracts/","pt-v5-twab-controller/=lib/pt-v5-twab-controller/src/","ring-buffer-lib/=lib/pt-v5-twab-controller/lib/ring-buffer-lib/src/","solady/=lib/uni-v3-lib/node_modules/solady/","solmate/=lib/solmate/src/","uni-v3-lib/=lib/uni-v3-lib/src/"],"optimizer":{"enabled":true,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/Stake.sol":"Stake"},"evmVersion":"prague","libraries":{}},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"keccak256":"0xac6c2efc64baccbde4904ae18ed45139c9aa8cff96d6888344d1e4d2eb8b659f","urls":["bzz-raw://6e416a280c610b6b7a5f158e4a41aacfaec01ef14d5d1de13b46be9e090265fc","dweb:/ipfs/QmYZP2KrdyccBbhLZT42auhvBTMkwiwUS3V6HWb42rbwbG"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol":{"keccak256":"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c","urls":["bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15","dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","urls":["bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5","dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Permit.sol":{"keccak256":"0xbb16110ffe0b625944fe7dd97adcf1158e514185c956a5628bc09be90d606174","urls":["bzz-raw://b5b412e554a4dd37a50f89ffcd7b9a6ef2ae5064f37619f89343b23d58ce89ca","dweb:/ipfs/QmPWMdBvdFk8WBVv625wd1Ar7aehnBWtj1XfFRrRL5KpxJ"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca","urls":["bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd","dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol":{"keccak256":"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69","urls":["bzz-raw://28879d01fd22c07b44f006612775f8577defbe459cb01685c5e25cd518c91a71","dweb:/ipfs/QmVgfkwv2Fxw6hhTcDUZhE7NkoSKjab3ipM7UaRbt6uXb5"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1","urls":["bzz-raw://9d213d3befca47da33f6db0310826bcdb148299805c10d77175ecfe1d06a9a68","dweb:/ipfs/QmRgCn6SP1hbBkExUADFuDo8xkT4UU47yjNF5FhCeRbQmS"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"keccak256":"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa","urls":["bzz-raw://2455248c8ddd9cc6a7af76a13973cddf222072427e7b0e2a7d1aff345145e931","dweb:/ipfs/QmfYjnjRbWqYpuxurqveE6HtzsY1Xx323J428AKQgtBJZm"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439","urls":["bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c","dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Counters.sol":{"keccak256":"0xf0018c2440fbe238dd3a8732fa8e17a0f9dce84d31451dc8a32f6d62b349c9f1","urls":["bzz-raw://59e1c62884d55b70f3ae5432b44bb3166ad71ae3acd19c57ab6ddc3c87c325ee","dweb:/ipfs/QmezuXg5GK5oeA4F91EZhozBFekhq5TD966bHPH18cCqhu"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"keccak256":"0xc0e310c163edf15db45d4ff938113ab357f94fa86e61ea8e790853c4d2e13256","urls":["bzz-raw://04db5bc05dcb05ba1f6ca2dfbead17adc8a2e2f911aa80b05e7a36d9eaf96516","dweb:/ipfs/QmVkfHZbXVBUPsTopueCn3qGJX8aEjahFF3Fn4NcygLNm5"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"keccak256":"0xf09e68aa0dc6722a25bc46490e8d48ed864466d17313b8a0b254c36b54e49899","urls":["bzz-raw://e26daf81e2252dc1fe1ce0e4b55c2eb7c6d1ee84ae6558d1a9554432ea1d32da","dweb:/ipfs/Qmb1UANWiWq5pCKbmHSu772hd4nt374dVaghGmwSVNuk8Q"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"keccak256":"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0","urls":["bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f","dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"keccak256":"0x809bc3edb4bcbef8263fa616c1b60ee0004b50a8a1bfa164d8f57fd31f520c58","urls":["bzz-raw://8b93a1e39a4a19eba1600b92c96f435442db88cac91e315c8291547a2a7bcfe2","dweb:/ipfs/QmTm34KVe6uZBZwq8dZDNWwPcm24qBJdxqL3rPxBJ4LrMv"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"keccak256":"0x8432884527a7ad91e6eed1cfc5a0811ae2073e5bca107bd0ca442e9236b03dbd","urls":["bzz-raw://e3aa0eadab7aafcf91a95684765f778f64386f0368de88522ce873c21385278a","dweb:/ipfs/QmPfaVAqWgH1QsT3dHVuL6jwMZbVKdoP8w1PvpiPT2FPWd"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"keccak256":"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3","urls":["bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c","dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"keccak256":"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc","urls":["bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7","dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6"],"license":"MIT"},"src/Kraiken.sol":{"keccak256":"0x1c942bc6eacd6f413c7e58e5d313e0a0b6ec642b4fcf28aedc7990f35df1d291","urls":["bzz-raw://8ba5284cf487489f6e33015ffcabafed502462e6ec27683e782066cc98cf861f","dweb:/ipfs/Qme8uPk4hQPNDqMYG2NVxhwpCuq2a32mQbsTk4sdHPPhjx"],"license":"GPL-3.0-or-later"},"src/Stake.sol":{"keccak256":"0x64c687de1691b550bf533c9c5a9b5774b2127fe7ba94872230b489d751d113f3","urls":["bzz-raw://66bb7c21be51cfe5b3066e2589df41b5fb14e635398fe9055799e0d6aa251e1a","dweb:/ipfs/QmVB3vnYz9HqgKXZgMXTqJA5ZqadF83mGyRUCgdRTcRhEB"],"license":"GPL-3.0-or-later"}},"version":1},"id":85}
\ No newline at end of file
diff --git a/tests/e2e/02-max-stake-all-tax-rates.spec.ts b/tests/e2e/02-max-stake-all-tax-rates.spec.ts
index e559ec5..a78eb77 100644
--- a/tests/e2e/02-max-stake-all-tax-rates.spec.ts
+++ b/tests/e2e/02-max-stake-all-tax-rates.spec.ts
@@ -72,6 +72,7 @@ test.describe('Max Stake All Tax Rates', () => {
   });
 
   test('fills all tax rates until maxStake is reached', async ({ browser, request }) => {
+    test.setTimeout(10 * 60 * 1000); // 10 minutes — this test creates 30 staking positions via UI
     console.log('[TEST] Creating wallet context...');
     const context = await createWalletContext(browser, {
       privateKey: ACCOUNT_PRIVATE_KEY,
diff --git a/tests/e2e/04-recenter-positions.spec.ts b/tests/e2e/04-recenter-positions.spec.ts
new file mode 100644
index 0000000..8f4f0a1
--- /dev/null
+++ b/tests/e2e/04-recenter-positions.spec.ts
@@ -0,0 +1,153 @@
+import { expect, test } from '@playwright/test';
+import { getStackConfig, validateStackHealthy } from '../setup/stack';
+
+const STACK_CONFIG = getStackConfig();
+const STACK_RPC_URL = STACK_CONFIG.rpcUrl;
+
+// Solidity function selectors
+const POSITIONS_SELECTOR = '0xf86aafc0'; // positions(uint8)
+const RECENTER_SELECTOR = '0xf46e1346'; // recenter()
+const RECENTER_ACCESS_SELECTOR = '0xdef51130'; // recenterAccess()
+
+// Position stages (matches ThreePositionStrategy.Stage enum)
+const STAGE_FLOOR = 0;
+const STAGE_ANCHOR = 1;
+const STAGE_DISCOVERY = 2;
+const STAGE_NAMES = ['FLOOR', 'ANCHOR', 'DISCOVERY'] as const;
+
+interface Position {
+  liquidity: bigint;
+  tickLower: number;
+  tickUpper: number;
+}
+
+async function rpcCall(method: string, params: unknown[]): Promise<unknown> {
+  const response = await fetch(STACK_RPC_URL, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+  });
+  const data = await response.json();
+  if (data.error) throw new Error(`RPC error: ${data.error.message}`);
+  return data.result;
+}
+
+async function rpcCallRaw(method: string, params: unknown[]): Promise<{ result?: unknown; error?: { message: string; data?: string } }> {
+  const response = await fetch(STACK_RPC_URL, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+  });
+  return response.json();
+}
+
+function readPosition(result: string): Position {
+  const liquidity = BigInt('0x' + result.slice(2, 66));
+  const tickLowerRaw = BigInt('0x' + result.slice(66, 130));
+  const tickUpperRaw = BigInt('0x' + result.slice(130, 194));
+
+  const toInt24 = (val: bigint): number => {
+    const n = Number(val & 0xffffffn);
+    return n >= 0x800000 ? n - 0x1000000 : n;
+  };
+
+  return {
+    liquidity,
+    tickLower: toInt24(tickLowerRaw),
+    tickUpper: toInt24(tickUpperRaw),
+  };
+}
+
+async function getPosition(lmAddress: string, stage: number): Promise<Position> {
+  const stageHex = stage.toString(16).padStart(64, '0');
+  const result = (await rpcCall('eth_call', [
+    { to: lmAddress, data: `${POSITIONS_SELECTOR}${stageHex}` },
+    'latest',
+  ])) as string;
+  return readPosition(result);
+}
+
+test.describe('Recenter Positions', () => {
+  test.beforeAll(async () => {
+    await validateStackHealthy(STACK_CONFIG);
+  });
+
+  test('bootstrap recenter created valid positions with liquidity', async () => {
+    const lmAddress = STACK_CONFIG.contracts.LiquidityManager;
+    console.log(`[TEST] LiquidityManager: ${lmAddress}`);
+
+    for (const stage of [STAGE_FLOOR, STAGE_ANCHOR, STAGE_DISCOVERY]) {
+      const position = await getPosition(lmAddress, stage);
+      const name = STAGE_NAMES[stage];
+      console.log(
+        `[TEST] ${name}: liquidity=${position.liquidity}, ticks=[${position.tickLower}, ${position.tickUpper}]`,
+      );
+
+      expect(position.liquidity).toBeGreaterThan(0n);
+      expect(position.tickUpper).toBeGreaterThan(position.tickLower);
+      console.log(`[TEST] ${name} position verified`);
+    }
+
+    // Verify position ordering: floor above anchor above discovery (token0isWeth)
+    const floor = await getPosition(lmAddress, STAGE_FLOOR);
+    const anchor = await getPosition(lmAddress, STAGE_ANCHOR);
+    const discovery = await getPosition(lmAddress, STAGE_DISCOVERY);
+
+    // Floor should be above anchor (higher tick = cheaper KRK side when token0isWeth)
+    expect(floor.tickLower).toBeGreaterThanOrEqual(anchor.tickUpper);
+    // Discovery should be below anchor
+    expect(discovery.tickUpper).toBeLessThanOrEqual(anchor.tickLower);
+
+    console.log('[TEST] Position ordering verified: discovery < anchor < floor');
+    console.log('[TEST] All three positions have non-zero liquidity');
+  });
+
+  test('recenter() enforces access control', async () => {
+    const lmAddress = STACK_CONFIG.contracts.LiquidityManager;
+
+    // Read the recenterAccess address
+    const recenterAccessResult = (await rpcCall('eth_call', [
+      { to: lmAddress, data: RECENTER_ACCESS_SELECTOR },
+      'latest',
+    ])) as string;
+    const recenterAddr = '0x' + recenterAccessResult.slice(26);
+    console.log(`[TEST] recenterAccess: ${recenterAddr}`);
+    expect(recenterAddr).not.toBe('0x' + '0'.repeat(40));
+    console.log('[TEST] recenterAccess is set (not zero address)');
+
+    // Try calling recenter from an unauthorized address — should revert with "access denied"
+    const unauthorizedAddr = '0x1111111111111111111111111111111111111111';
+    const callResult = await rpcCallRaw('eth_call', [
+      { from: unauthorizedAddr, to: lmAddress, data: RECENTER_SELECTOR },
+      'latest',
+    ]);
+
+    expect(callResult.error).toBeDefined();
+    expect(callResult.error!.message).toContain('access denied');
+    console.log('[TEST] Unauthorized recenter correctly rejected with "access denied"');
+  });
+
+  test('recenter() enforces amplitude check', async () => {
+    const lmAddress = STACK_CONFIG.contracts.LiquidityManager;
+
+    // Read the recenterAccess address
+    const recenterAccessResult = (await rpcCall('eth_call', [
+      { to: lmAddress, data: RECENTER_ACCESS_SELECTOR },
+      'latest',
+    ])) as string;
+    const recenterAddr = '0x' + recenterAccessResult.slice(26);
+
+    // Call recenter from the authorized address without moving the price
+    // Should revert with "amplitude not reached" since price hasn't moved enough
+    const callResult = await rpcCallRaw('eth_call', [
+      { from: recenterAddr, to: lmAddress, data: RECENTER_SELECTOR },
+      'latest',
+    ]);
+
+    // The call should fail — either "amplitude not reached" or just revert
+    // (Pool state may vary, but it should not succeed without price movement)
+    expect(callResult.error).toBeDefined();
+    console.log(`[TEST] Recenter guard active: ${callResult.error!.message}`);
+    console.log('[TEST] Recenter correctly prevents no-op recentering');
+  });
+});
diff --git a/tests/e2e/05-optimizer-integration.spec.ts b/tests/e2e/05-optimizer-integration.spec.ts
new file mode 100644
index 0000000..b37833f
--- /dev/null
+++ b/tests/e2e/05-optimizer-integration.spec.ts
@@ -0,0 +1,177 @@
+import { expect, test } from '@playwright/test';
+import { getStackConfig, validateStackHealthy } from '../setup/stack';
+
+const STACK_CONFIG = getStackConfig();
+const STACK_RPC_URL = STACK_CONFIG.rpcUrl;
+
+// Solidity function selectors
+const GET_LIQUIDITY_PARAMS_SELECTOR = '0xbd53c0dc'; // getLiquidityParams()
+const POSITIONS_SELECTOR = '0xf86aafc0'; // positions(uint8)
+// OptimizerV3 known bear-market parameters
+const BEAR_ANCHOR_SHARE = 3n * 10n ** 17n; // 3e17 = 30%
+const BEAR_ANCHOR_WIDTH = 100n;
+const BEAR_DISCOVERY_DEPTH = 3n * 10n ** 17n; // 3e17
+
+// Position stages
+const STAGE_FLOOR = 0;
+const STAGE_ANCHOR = 1;
+const STAGE_DISCOVERY = 2;
+
+// TICK_SPACING from ThreePositionStrategy
+const TICK_SPACING = 200;
+
+interface LiquidityParams {
+  capitalInefficiency: bigint;
+  anchorShare: bigint;
+  anchorWidth: bigint;
+  discoveryDepth: bigint;
+}
+
+async function rpcCall(method: string, params: unknown[]): Promise<unknown> {
+  const response = await fetch(STACK_RPC_URL, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+  });
+  const data = await response.json();
+  if (data.error) throw new Error(`RPC error: ${data.error.message}`);
+  return data.result;
+}
+
+async function readLiquidityParams(optimizerAddress: string): Promise<LiquidityParams> {
+  const result = (await rpcCall('eth_call', [
+    { to: optimizerAddress, data: GET_LIQUIDITY_PARAMS_SELECTOR },
+    'latest',
+  ])) as string;
+
+  return {
+    capitalInefficiency: BigInt('0x' + result.slice(2, 66)),
+    anchorShare: BigInt('0x' + result.slice(66, 130)),
+    anchorWidth: BigInt('0x' + result.slice(130, 194)),
+    discoveryDepth: BigInt('0x' + result.slice(194, 258)),
+  };
+}
+
+function toInt24(val: bigint): number {
+  const n = Number(val & 0xffffffn);
+  return n >= 0x800000 ? n - 0x1000000 : n;
+}
+
+test.describe('Optimizer Integration', () => {
+  test.beforeAll(async () => {
+    await validateStackHealthy(STACK_CONFIG);
+  });
+
+  test('OptimizerV3 proxy returns valid bear-market parameters', async () => {
+    const optimizerAddress = STACK_CONFIG.contracts.OptimizerProxy;
+    if (!optimizerAddress) {
+      console.log(
+        '[TEST] SKIP: OptimizerProxy not in deployments-local.json (older deployment)',
+      );
+      test.skip();
+      return;
+    }
+
+    console.log(`[TEST] OptimizerProxy: ${optimizerAddress}`);
+
+    const params = await readLiquidityParams(optimizerAddress);
+    console.log(`[TEST] capitalInefficiency: ${params.capitalInefficiency}`);
+    console.log(`[TEST] anchorShare:         ${params.anchorShare}`);
+    console.log(`[TEST] anchorWidth:         ${params.anchorWidth}`);
+    console.log(`[TEST] discoveryDepth:      ${params.discoveryDepth}`);
+
+    // With no staking activity, OptimizerV3 should return bear-market defaults
+    expect(params.capitalInefficiency).toBe(0n);
+    expect(params.anchorShare).toBe(BEAR_ANCHOR_SHARE);
+    expect(params.anchorWidth).toBe(BEAR_ANCHOR_WIDTH);
+    expect(params.discoveryDepth).toBe(BEAR_DISCOVERY_DEPTH);
+
+    console.log('[TEST] OptimizerV3 returns correct bear-market parameters');
+  });
+
+  test('bootstrap positions reflect optimizer anchorWidth=100 parameter', async () => {
+    const lmAddress = STACK_CONFIG.contracts.LiquidityManager;
+    const optimizerAddress = STACK_CONFIG.contracts.OptimizerProxy;
+    if (!optimizerAddress) {
+      test.skip();
+      return;
+    }
+
+    // Read optimizer params
+    const params = await readLiquidityParams(optimizerAddress);
+    const anchorWidth = Number(params.anchorWidth);
+    console.log(`[TEST] Optimizer anchorWidth: ${anchorWidth}`);
+
+    // Read anchor position from LM (created by bootstrap's recenter call)
+    const anchorResult = (await rpcCall('eth_call', [
+      {
+        to: lmAddress,
+        data: `${POSITIONS_SELECTOR}${'1'.padStart(64, '0')}`, // Stage.ANCHOR = 1
+      },
+      'latest',
+    ])) as string;
+
+    const tickLower = toInt24(BigInt('0x' + anchorResult.slice(66, 130)));
+    const tickUpper = toInt24(BigInt('0x' + anchorResult.slice(130, 194)));
+    const anchorSpread = tickUpper - tickLower;
+
+    console.log(`[TEST] Anchor position: ticks=[${tickLower}, ${tickUpper}], spread=${anchorSpread}`);
+
+    // Verify the anchor spread matches the optimizer formula:
+    // anchorSpacing = TICK_SPACING + (34 * anchorWidth * TICK_SPACING / 100)
+    // For anchorWidth=100: anchorSpacing = 200 + (34 * 100 * 200 / 100) = 200 + 6800 = 7000
+    // Full anchor = 2 * anchorSpacing = 14000 ticks
+    const expectedSpacing = TICK_SPACING + (34 * anchorWidth * TICK_SPACING) / 100;
+    const expectedSpread = expectedSpacing * 2;
+    console.log(`[TEST] Expected anchor spread: ${expectedSpread} (anchorSpacing=${expectedSpacing})`);
+
+    expect(anchorSpread).toBe(expectedSpread);
+    console.log('[TEST] Anchor spread matches optimizer anchorWidth=100 formula');
+  });
+
+  test('all three positions have valid relative sizing', async () => {
+    const lmAddress = STACK_CONFIG.contracts.LiquidityManager;
+    const optimizerAddress = STACK_CONFIG.contracts.OptimizerProxy;
+    if (!optimizerAddress) {
+      test.skip();
+      return;
+    }
+
+    // Read all three positions
+    const positions = [];
+    const stageNames = ['FLOOR', 'ANCHOR', 'DISCOVERY'];
+    for (const stage of [STAGE_FLOOR, STAGE_ANCHOR, STAGE_DISCOVERY]) {
+      const stageHex = stage.toString(16).padStart(64, '0');
+      const result = (await rpcCall('eth_call', [
+        { to: lmAddress, data: `${POSITIONS_SELECTOR}${stageHex}` },
+        'latest',
+      ])) as string;
+
+      const liquidity = BigInt('0x' + result.slice(2, 66));
+      const tickLower = toInt24(BigInt('0x' + result.slice(66, 130)));
+      const tickUpper = toInt24(BigInt('0x' + result.slice(130, 194)));
+      const spread = tickUpper - tickLower;
+
+      positions.push({ liquidity, tickLower, tickUpper, spread });
+      console.log(`[TEST] ${stageNames[stage]}: spread=${spread}, liquidity=${liquidity}`);
+    }
+
+    // Floor should be narrow (TICK_SPACING width = 200 ticks)
+    expect(positions[0].spread).toBe(TICK_SPACING);
+    console.log('[TEST] Floor has expected narrow width (200 ticks)');
+
+    // Anchor should be wider than floor
+    expect(positions[1].spread).toBeGreaterThan(positions[0].spread);
+    console.log('[TEST] Anchor is wider than floor');
+
+    // Discovery should have significant spread
+    expect(positions[2].spread).toBeGreaterThan(0);
+    console.log('[TEST] Discovery has positive spread');
+
+    // Floor liquidity should be highest (concentrated in narrow range)
+    expect(positions[0].liquidity).toBeGreaterThan(positions[1].liquidity);
+    console.log('[TEST] Floor liquidity > anchor liquidity (as expected for concentrated position)');
+
+    console.log('[TEST] All position sizing validated against optimizer parameters');
+  });
+});
diff --git a/tests/setup/stack.ts b/tests/setup/stack.ts
index 5b2c8f4..edd5498 100644
--- a/tests/setup/stack.ts
+++ b/tests/setup/stack.ts
@@ -13,6 +13,7 @@ export interface ContractAddresses {
   Kraiken: string;
   Stake: string;
   LiquidityManager: string;
+  OptimizerProxy?: string;
 }
 
 export interface StackConfig {