From 7794ccfb67a50f4326d4c9820644da92dcd21bb8 Mon Sep 17 00:00:00 2001 From: enitrat Date: Sat, 25 Oct 2025 19:43:29 +0200 Subject: [PATCH 1/4] dev: reorganize codebase structure --- .gitignore | 1 - CLAUDE.md | 4 +- ingester.dockerfile | 2 +- ingesters/src/ingesters/CairoBookIngester.ts | 4 +- .../src/ingesters/CoreLibDocsIngester.ts | 4 +- .../src/ingesters/StarknetBlogIngester.ts | 4 +- python/pyproject.toml | 14 +- python/src/cairo_coder_tools/__init__.py | 1 + .../cairo_coder_tools/datasets/__init__.py | 5 + .../datasets/analysis.py} | 78 +- .../datasets/extractors.py | 0 .../src/cairo_coder_tools/evals/__init__.py | 1 + .../evals/starklings/__init__.py | 17 + .../evals/starklings}/api_client.py | 0 .../evals/starklings}/evaluator.py | 0 .../evals/starklings}/models.py | 0 .../evals/starklings}/report_generator.py | 0 .../ingestion}/__init__.py | 0 .../ingestion}/base_summarizer.py | 2 +- .../ingestion}/cli.py | 0 .../ingestion/crawler.py} | 180 +- .../ingestion}/doc_dump_summarizer.py | 0 .../ingestion}/dpsy_summarizer.py | 0 .../ingestion/generated/blog_summary.md | 7239 +++++++++++++++++ .../generated/cairo_book_summary.md | 0 .../ingestion}/generated/corelib_summary.md | 0 .../ingestion}/header_fixer.py | 0 .../ingestion}/mdbook_summarizer.py | 0 .../ingestion}/summarizer_factory.py | 0 python/src/scripts/README.md | 164 + .../scripts/README_starklings_evaluation.md | 168 - .../scripts/{datasets/cli.py => dataset.py} | 71 +- .../{starklings_evaluate.py => eval.py} | 21 +- python/src/scripts/filter_2025_blogs.py | 147 - python/src/scripts/ingest.py | 407 + .../summarizer/generated/blog_summary.md | 4450 ---------- 36 files changed, 8120 insertions(+), 4864 deletions(-) create mode 100644 python/src/cairo_coder_tools/__init__.py create mode 100644 python/src/cairo_coder_tools/datasets/__init__.py rename python/src/{scripts/llm_dataset_analysis.py => cairo_coder_tools/datasets/analysis.py} (51%) rename python/src/{cairo_coder => cairo_coder_tools}/datasets/extractors.py (100%) create mode 100644 python/src/cairo_coder_tools/evals/__init__.py create mode 100644 python/src/cairo_coder_tools/evals/starklings/__init__.py rename python/src/{scripts/starklings_evaluation => cairo_coder_tools/evals/starklings}/api_client.py (100%) rename python/src/{scripts/starklings_evaluation => cairo_coder_tools/evals/starklings}/evaluator.py (100%) rename python/src/{scripts/starklings_evaluation => cairo_coder_tools/evals/starklings}/models.py (100%) rename python/src/{scripts/starklings_evaluation => cairo_coder_tools/evals/starklings}/report_generator.py (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/__init__.py (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/base_summarizer.py (97%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/cli.py (100%) rename python/src/{scripts/docs_crawler.py => cairo_coder_tools/ingestion/crawler.py} (70%) mode change 100755 => 100644 rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/doc_dump_summarizer.py (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/dpsy_summarizer.py (100%) create mode 100644 python/src/cairo_coder_tools/ingestion/generated/blog_summary.md rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/generated/cairo_book_summary.md (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/generated/corelib_summary.md (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/header_fixer.py (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/mdbook_summarizer.py (100%) rename python/src/{scripts/summarizer => cairo_coder_tools/ingestion}/summarizer_factory.py (100%) create mode 100644 python/src/scripts/README.md delete mode 100644 python/src/scripts/README_starklings_evaluation.md rename python/src/scripts/{datasets/cli.py => dataset.py} (77%) rename python/src/scripts/{starklings_evaluate.py => eval.py} (91%) mode change 100755 => 100644 delete mode 100644 python/src/scripts/filter_2025_blogs.py create mode 100644 python/src/scripts/ingest.py delete mode 100644 python/src/scripts/summarizer/generated/blog_summary.md diff --git a/.gitignore b/.gitignore index 4aaaa8e1..f347d7bd 100644 --- a/.gitignore +++ b/.gitignore @@ -47,7 +47,6 @@ packages/**/dist !.trunk/trunk.yaml !.trunk/.gitignore -starklings/ debug/ fixtures/runner_crate/target diff --git a/CLAUDE.md b/CLAUDE.md index 634d7946..f944962d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -118,8 +118,8 @@ ingesters/ ```text Python Summarizer → Generated Markdown → Ingester → PostgreSQL → RAG Pipeline → Code Generation - (python/) (python/src/scripts/ (ingesters/) (pgvector) (python/) - summarizer/generated/) + (python/) (python/src/cairo_coder_tools/ (ingesters/) (pgvector) (python/) + ingestion/generated/) ``` ## Configuration diff --git a/ingester.dockerfile b/ingester.dockerfile index ecbc5d6d..c5f2ae19 100644 --- a/ingester.dockerfile +++ b/ingester.dockerfile @@ -16,7 +16,7 @@ COPY ingesters ./ingesters # Copy ingester files generated from python -COPY python/src/scripts/summarizer/generated ./python/src/scripts/summarizer/generated +COPY python/src/cairo_coder_tools/ingestion/generated ./python/src/cairo_coder_tools/ingestion/generated # Install dependencies WORKDIR /app/ingesters diff --git a/ingesters/src/ingesters/CairoBookIngester.ts b/ingesters/src/ingesters/CairoBookIngester.ts index e2c8ec39..5de9b9eb 100644 --- a/ingesters/src/ingesters/CairoBookIngester.ts +++ b/ingesters/src/ingesters/CairoBookIngester.ts @@ -46,8 +46,8 @@ export class CairoBookIngester extends MarkdownIngester { async readSummaryFile(): Promise { const summaryPath = getPythonPath( 'src', - 'scripts', - 'summarizer', + 'cairo_coder_tools', + 'ingestion', 'generated', 'cairo_book_summary.md', ); diff --git a/ingesters/src/ingesters/CoreLibDocsIngester.ts b/ingesters/src/ingesters/CoreLibDocsIngester.ts index 18f093d0..648cfcd6 100644 --- a/ingesters/src/ingesters/CoreLibDocsIngester.ts +++ b/ingesters/src/ingesters/CoreLibDocsIngester.ts @@ -46,8 +46,8 @@ export class CoreLibDocsIngester extends MarkdownIngester { async readCorelibSummaryFile(): Promise { const summaryPath = getPythonPath( 'src', - 'scripts', - 'summarizer', + 'cairo_coder_tools', + 'ingestion', 'generated', 'corelib_summary.md', ); diff --git a/ingesters/src/ingesters/StarknetBlogIngester.ts b/ingesters/src/ingesters/StarknetBlogIngester.ts index ff913b54..d2e9c88c 100644 --- a/ingesters/src/ingesters/StarknetBlogIngester.ts +++ b/ingesters/src/ingesters/StarknetBlogIngester.ts @@ -47,8 +47,8 @@ export class StarknetBlogIngester extends MarkdownIngester { async readSummaryFile(): Promise { const summaryPath = getPythonPath( 'src', - 'scripts', - 'summarizer', + 'cairo_coder_tools', + 'ingestion', 'generated', 'blog_summary.md', ); diff --git a/python/pyproject.toml b/python/pyproject.toml index a65f86b8..97e72f14 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -71,14 +71,18 @@ dev = [ ] [project.scripts] +# Main server cairo-coder = "cairo_coder.server.app:main" cairo-coder-api = "cairo_coder.api.server:run" + +# Optimization tools generate_starklings_dataset = "cairo_coder.optimizers.generation.generate_starklings_dataset:cli_main" optimize_generation = "cairo_coder.optimizers.generation.optimize_generation:main" -starklings_evaluate = "scripts.starklings_evaluate:main" -cairo-coder-summarize = "scripts.summarizer.cli:app" -docs-crawler = "scripts.docs_crawler:main" -cairo-coder-datasets = "scripts.datasets.cli:app" + +# Other scripts +eval = "scripts.eval:main" +ingest = "scripts.ingest:app" +dataset = "scripts.dataset:app" [project.urls] "Homepage" = "https://github.com/cairo-coder/cairo-coder" @@ -86,7 +90,7 @@ cairo-coder-datasets = "scripts.datasets.cli:app" [tool.uv.build-backend] module-root = "src" -module-name = ["cairo_coder", "scripts"] +module-name = ["cairo_coder", "cairo_coder_tools", "scripts"] [tool.ruff] line-length = 100 diff --git a/python/src/cairo_coder_tools/__init__.py b/python/src/cairo_coder_tools/__init__.py new file mode 100644 index 00000000..6cf90eb5 --- /dev/null +++ b/python/src/cairo_coder_tools/__init__.py @@ -0,0 +1 @@ +"""Cairo Coder Tools - Utilities for evaluation, ingestion, and dataset management.""" diff --git a/python/src/cairo_coder_tools/datasets/__init__.py b/python/src/cairo_coder_tools/datasets/__init__.py new file mode 100644 index 00000000..9c70b8a6 --- /dev/null +++ b/python/src/cairo_coder_tools/datasets/__init__.py @@ -0,0 +1,5 @@ +"""Dataset utilities for Cairo Coder.""" + +from .analysis import DatasetAnalyzer, analyze_dataset + +__all__ = ["DatasetAnalyzer", "analyze_dataset"] diff --git a/python/src/scripts/llm_dataset_analysis.py b/python/src/cairo_coder_tools/datasets/analysis.py similarity index 51% rename from python/src/scripts/llm_dataset_analysis.py rename to python/src/cairo_coder_tools/datasets/analysis.py index 671a4b42..6244af11 100644 --- a/python/src/scripts/llm_dataset_analysis.py +++ b/python/src/cairo_coder_tools/datasets/analysis.py @@ -1,22 +1,25 @@ -# Quick CLI script to analyze a dataset of question-answer pairs. +"""Dataset analysis module for Cairo Coder. + +This module provides tools for analyzing question-answer datasets using LLMs. +""" import json +from pathlib import Path +from typing import Any import dspy from dspy.adapters.baml_adapter import BAMLAdapter class DatasetAnalyzer(dspy.Signature): - """ - You are provided a dataset of question-answer pairs. - This dataset is related to the Starknet blockchain and the Cairo programming language, and contains - mostly technical questions about code, infrastructure, and the overall Starknet ecosystem. - Your task is to analyze the dataset and provide valuable insights. + """Analyze a dataset of question-answer pairs. + + This signature is designed for analyzing datasets related to the Starknet + blockchain and Cairo programming language, containing mostly technical + questions about code, infrastructure, and the Starknet ecosystem. """ - dataset: list[dict] = dspy.InputField( - desc="The dataset of question-answer pairs." - ) + dataset: list[dict] = dspy.InputField(desc="The dataset of question-answer pairs.") languages: list[str] = dspy.OutputField( desc="The list of all languages users have asked queries with." ) @@ -30,7 +33,7 @@ class DatasetAnalyzer(dspy.Signature): - "When im importing stuff from a file in my smart contract, what is the difference between super:: and crate:: ?" -> "Cairo language questions" - "how to use the `assert!` macro in my smart contract" -> "Cairo language questions" - "I am writing a function in my smart contract. I need to be sure the caller has enough balance or it reverts. how do I do this?" -> "Starknet smart contracts questions" - - "what does this error mean :\n```\n Account validation failed: \"StarknetError { code: KnownErrorCode(ValidateFailure), message: 'The 'validate' entry point panicked with: nError in contract (contract address: 0x0762c126b2655bc371c1075e2914edd42ba40fc2c485b5e8772f05c7e09fec26, class hash: 0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f, selector: 0x0289da278a8dc833409cabfdad1581e8e7d40e42dcaed693fa4008dcdb4963b3): n0x617267656e742f696e76616c69642d7369676e61747572652d6c656e677468 ('argent invalid signature length'). n' }```" -> "Debugging errors questions" + - "what does this error mean :\\n```\\n Account validation failed: \\"StarknetError { code: KnownErrorCode(ValidateFailure), message: 'The 'validate' entry point panicked with: nError in contract (contract address: 0x0762c126b2655bc371c1075e2914edd42ba40fc2c485b5e8772f05c7e09fec26, class hash: 0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f, selector: 0x0289da278a8dc833409cabfdad1581e8e7d40e42dcaed693fa4008dcdb4963b3): n0x617267656e742f696e76616c69642d7369676e61747572652d6c656e677468 ('argent invalid signature length'). n' }\\"```" -> "Debugging errors questions" - "How to declare and deploy a contract with constructor to sepolia or mainnet using starkli?" -> "Starknet network interactions questions" """ ) @@ -44,23 +47,50 @@ class DatasetAnalyzer(dspy.Signature): """ ) -def main(): - dspy.configure(lm=dspy.LM("openrouter/x-ai/grok-4-fast:free", max_tokens=30000, cache=False), adapter=BAMLAdapter()) - with open("qa_pairs.json") as f: +class AnalysisResponse: + languages: list[str] + topics: list[tuple[str, int]] + analysis: str + +def analyze_dataset( + dataset_path: Path, + output_path: Path, + lm_model: str = "openrouter/x-ai/grok-4-fast:free", + max_tokens: int = 30000, +) -> AnalysisResponse: + """Analyze a dataset of question-answer pairs. + + Args: + dataset_path: Path to the input dataset JSON file + output_path: Path to save the analysis results + lm_model: Language model to use for analysis + max_tokens: Maximum tokens for the LLM response + + Returns: + Dictionary containing the analysis results + """ + # Configure DSPy + dspy.configure(lm=dspy.LM(lm_model, max_tokens=max_tokens, cache=False), adapter=BAMLAdapter()) + + # Load dataset + with open(dataset_path) as f: dataset = json.load(f) + + # Run analysis analyzer = dspy.ChainOfThought(DatasetAnalyzer) response = analyzer(dataset=dataset) - response_dict = { - "languages": response.languages, - "topics": response.topics, - "analysis": response.analysis - } - - with open("analysis.json", "w") as f: - json.dump(response_dict, f, indent=4) - + # Create response dictionary + response = AnalysisResponse( + languages=response.languages, + topics=response.topics, + analysis=response.analysis, + ) + # Save results + output_path = Path(output_path) + output_path.parent.mkdir(parents=True, exist_ok=True) + with open(output_path, "w") as f: + json.dump(response.model_dump(), f, indent=4) -if __name__ == "__main__": - main() + return response diff --git a/python/src/cairo_coder/datasets/extractors.py b/python/src/cairo_coder_tools/datasets/extractors.py similarity index 100% rename from python/src/cairo_coder/datasets/extractors.py rename to python/src/cairo_coder_tools/datasets/extractors.py diff --git a/python/src/cairo_coder_tools/evals/__init__.py b/python/src/cairo_coder_tools/evals/__init__.py new file mode 100644 index 00000000..5b086298 --- /dev/null +++ b/python/src/cairo_coder_tools/evals/__init__.py @@ -0,0 +1 @@ +"""Evaluation modules for Cairo Coder.""" diff --git a/python/src/cairo_coder_tools/evals/starklings/__init__.py b/python/src/cairo_coder_tools/evals/starklings/__init__.py new file mode 100644 index 00000000..22775e55 --- /dev/null +++ b/python/src/cairo_coder_tools/evals/starklings/__init__.py @@ -0,0 +1,17 @@ +"""Starklings evaluation suite.""" + +from .api_client import CairoCoderAPIClient, extract_code_from_response +from .evaluator import StarklingsEvaluator +from .models import CategoryResult, ConsolidatedReport, EvaluationRun, StarklingsSolution +from .report_generator import ReportGenerator + +__all__ = [ + "CairoCoderAPIClient", + "extract_code_from_response", + "StarklingsEvaluator", + "CategoryResult", + "ConsolidatedReport", + "EvaluationRun", + "StarklingsSolution", + "ReportGenerator", +] diff --git a/python/src/scripts/starklings_evaluation/api_client.py b/python/src/cairo_coder_tools/evals/starklings/api_client.py similarity index 100% rename from python/src/scripts/starklings_evaluation/api_client.py rename to python/src/cairo_coder_tools/evals/starklings/api_client.py diff --git a/python/src/scripts/starklings_evaluation/evaluator.py b/python/src/cairo_coder_tools/evals/starklings/evaluator.py similarity index 100% rename from python/src/scripts/starklings_evaluation/evaluator.py rename to python/src/cairo_coder_tools/evals/starklings/evaluator.py diff --git a/python/src/scripts/starklings_evaluation/models.py b/python/src/cairo_coder_tools/evals/starklings/models.py similarity index 100% rename from python/src/scripts/starklings_evaluation/models.py rename to python/src/cairo_coder_tools/evals/starklings/models.py diff --git a/python/src/scripts/starklings_evaluation/report_generator.py b/python/src/cairo_coder_tools/evals/starklings/report_generator.py similarity index 100% rename from python/src/scripts/starklings_evaluation/report_generator.py rename to python/src/cairo_coder_tools/evals/starklings/report_generator.py diff --git a/python/src/scripts/summarizer/__init__.py b/python/src/cairo_coder_tools/ingestion/__init__.py similarity index 100% rename from python/src/scripts/summarizer/__init__.py rename to python/src/cairo_coder_tools/ingestion/__init__.py diff --git a/python/src/scripts/summarizer/base_summarizer.py b/python/src/cairo_coder_tools/ingestion/base_summarizer.py similarity index 97% rename from python/src/scripts/summarizer/base_summarizer.py rename to python/src/cairo_coder_tools/ingestion/base_summarizer.py index 0d177e0b..06c2a25b 100644 --- a/python/src/scripts/summarizer/base_summarizer.py +++ b/python/src/cairo_coder_tools/ingestion/base_summarizer.py @@ -17,7 +17,7 @@ class SummarizerConfig: repo_url: str branch: Optional[str] subdirectory: Optional[str] - output_path: Path = Path("scripts/summarizer/generated/summary.md") + output_path: Path = Path("cairo_coder_tools/ingestion/generated/summary.md") class BaseSummarizer(ABC): diff --git a/python/src/scripts/summarizer/cli.py b/python/src/cairo_coder_tools/ingestion/cli.py similarity index 100% rename from python/src/scripts/summarizer/cli.py rename to python/src/cairo_coder_tools/ingestion/cli.py diff --git a/python/src/scripts/docs_crawler.py b/python/src/cairo_coder_tools/ingestion/crawler.py old mode 100755 new mode 100644 similarity index 70% rename from python/src/scripts/docs_crawler.py rename to python/src/cairo_coder_tools/ingestion/crawler.py index 498440de..2899d71e --- a/python/src/scripts/docs_crawler.py +++ b/python/src/cairo_coder_tools/ingestion/crawler.py @@ -1,15 +1,15 @@ #!/usr/bin/env python3 """Documentation Snapshot Crawler - Extract clean documentation content from websites.""" -import argparse import asyncio import logging +import os import re import xml.etree.ElementTree as ET from collections import deque from datetime import datetime, timezone from pathlib import Path -from typing import Optional +from typing import Callable, Optional from urllib.parse import urljoin, urlparse, urlunparse import aiohttp @@ -20,7 +20,7 @@ # Configuration UA = "NotebookLM-prep-crawler/1.1 (+contact: you@example.com)" OUT_FILE = Path("doc_dump") -CONCURRENCY = 4 # Reduced from 6 to avoid rate limits +CONCURRENCY = 4 # Low concurrency to avoid rate limits MAX_RETRIES = 5 TIMEOUT = 30 MAX_CRAWL_PAGES = 100 @@ -42,18 +42,42 @@ '.container-fluid', '.container', '.wrapper' ] -logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') +# Respect LOG_LEVEL env var (e.g., DEBUG, INFO, WARNING) +_env_level = getattr(logging, str(os.environ.get("LOG_LEVEL", "INFO")).upper(), logging.INFO) +logging.basicConfig(level=_env_level, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) class DocsCrawler: - def __init__(self, base_url: str): + """Web crawler for documentation sites with filtering capabilities.""" + + def __init__( + self, + base_url: str, + include_patterns: Optional[list[str]] = None, + exclude_url_patterns: Optional[list[str]] = None, + content_filter: Optional[Callable[[str], bool]] = None, + content_processor: Optional[Callable[[str], str]] = None, + ): + """Initialize the crawler. + + Args: + base_url: Base URL to start crawling from + include_patterns: Optional list of regex patterns for URLs to include + exclude_url_patterns: Optional list of regex patterns for URLs to exclude + content_filter: Optional function that returns True if content should be kept + content_processor: Optional function to post-process content (e.g., remove sections) + """ self.base_url = base_url.rstrip('/') + '/' self.domain = urlparse(self.base_url).netloc self.discovered_urls: list[str] = [] self.fetched_pages: dict[str, dict] = {} self.session: Optional[aiohttp.ClientSession] = None self.semaphore = asyncio.Semaphore(CONCURRENCY) + self.include_patterns = include_patterns or [] + self.exclude_url_patterns = exclude_url_patterns or [] + self.content_filter = content_filter + self.content_processor = content_processor async def __aenter__(self): timeout = aiohttp.ClientTimeout(total=TIMEOUT) @@ -68,7 +92,7 @@ async def __aexit__(self, exc_type, exc_val, exc_tb): await self.session.close() def is_valid_url(self, url: str) -> bool: - """Check if URL should be included.""" + """Check if URL should be included during discovery (basic validation only).""" parsed = urlparse(url) base_parsed = urlparse(self.base_url) @@ -86,10 +110,41 @@ def is_valid_url(self, url: str) -> bool: if parsed.query: return False - # Check exclude patterns + # Check default exclude patterns (common non-content paths) path = parsed.path return not any(re.search(pattern, path, re.IGNORECASE) for pattern in EXCLUDE_PATTERNS) + def filter_urls(self, urls: list[str]) -> list[str]: + """Filter URLs based on include/exclude patterns. + + This is applied AFTER discovery and BEFORE fetching. + + Args: + urls: List of discovered URLs + + Returns: + Filtered list of URLs + """ + filtered_urls = [] + + for url in urls: + parsed = urlparse(url) + path = parsed.path + + # Check include patterns if provided + if self.include_patterns: + if not any(re.search(pattern, path, re.IGNORECASE) for pattern in self.include_patterns): + continue + + # Check custom exclude patterns (user-provided) + if self.exclude_url_patterns: + if any(re.search(pattern, path, re.IGNORECASE) for pattern in self.exclude_url_patterns): + continue + + filtered_urls.append(url) + + return filtered_urls + def normalize_url(self, url: str) -> str: """Remove fragment and normalize URL.""" parsed = urlparse(url) @@ -223,6 +278,7 @@ def sort_key(url: str) -> tuple: async def fetch_page(self, url: str) -> dict: """Fetch a single page with retries.""" async with self.semaphore: + last_error = "Unknown error" for attempt in range(MAX_RETRIES): try: async with self.session.get(url) as response: @@ -236,6 +292,17 @@ async def fetch_page(self, url: str) -> dict: 'content': html, 'error': None } + + # Handle rate limiting (429) and server errors (5xx) with retry + if response.status == 429 or response.status >= 500: + last_error = f"Status {response.status}" + if attempt < MAX_RETRIES - 1: + wait_time = 2 ** attempt + logger.debug(f"Got {response.status} for {url}, retrying in {wait_time}s (attempt {attempt + 1}/{MAX_RETRIES})") + await asyncio.sleep(wait_time) + continue + + # For other non-200 statuses, return immediately (no retry) return { 'url': url, 'status': response.status, @@ -244,18 +311,26 @@ async def fetch_page(self, url: str) -> dict: } except asyncio.TimeoutError: - error = "Timeout" + last_error = "Timeout" + if attempt < MAX_RETRIES - 1: + wait_time = 2 ** attempt + logger.debug(f"Timeout for {url}, retrying in {wait_time}s (attempt {attempt + 1}/{MAX_RETRIES})") + await asyncio.sleep(wait_time) + continue except Exception as e: - error = str(e) - - if attempt < MAX_RETRIES - 1: - await asyncio.sleep(2 ** attempt) # Exponential backoff - + last_error = str(e) + if attempt < MAX_RETRIES - 1: + wait_time = 2 ** attempt + logger.debug(f"Error for {url}: {e}, retrying in {wait_time}s (attempt {attempt + 1}/{MAX_RETRIES})") + await asyncio.sleep(wait_time) + continue + + # All retries exhausted return { 'url': url, 'status': None, 'content': None, - 'error': error + 'error': f"Failed after {MAX_RETRIES} attempts: {last_error}" } def extract_content(self, html: str, url: str) -> tuple[str, str]: @@ -347,12 +422,22 @@ def compile_markdown(self) -> str: ] # Process each page + filtered_out = 0 for url in self.discovered_urls: page_data = self.fetched_pages.get(url, {}) if page_data.get('content'): title, markdown = self.extract_content(page_data['content'], url) + # Apply content filter if provided + if self.content_filter and not self.content_filter(markdown): + filtered_out += 1 + continue + + # Apply content processor if provided (e.g., remove unwanted sections) + if self.content_processor: + markdown = self.content_processor(markdown) + if not markdown or len(markdown.strip()) < 50: markdown = "*No content extracted.*" @@ -373,13 +458,21 @@ def compile_markdown(self) -> str: error = page_data.get('error', 'Unknown error') logger.info(f"Skipping {url}: {error}") + logger.info(f"Filtered out {filtered_out} pages based on content filter: {self.content_filter}") return '\n'.join(lines) - async def run(self) -> None: - """Main execution flow.""" + async def run(self, output_path: Optional[Path] = None) -> Path: + """Main execution flow. + + Args: + output_path: Optional output path for the markdown file + + Returns: + Path to the generated markdown file + """ logger.info(f"Starting documentation crawler for: {self.base_url}") - # Discovery phase + # Phase 1: Discovery - find all URLs self.discovered_urls = await self.discover_urls_from_sitemap() if not self.discovered_urls: @@ -388,45 +481,42 @@ async def run(self) -> None: if not self.discovered_urls: logger.error("No URLs discovered!") - return + raise RuntimeError("No URLs discovered") - logger.info(f"Processing {len(self.discovered_urls)} URLs in order:") + logger.info(f"Discovered {len(self.discovered_urls)} URLs") + + # Phase 2: Filtering - apply include/exclude patterns + original_count = len(self.discovered_urls) + self.discovered_urls = self.filter_urls(self.discovered_urls) + filtered_count = original_count - len(self.discovered_urls) + + if filtered_count > 0: + logger.info(f"Filtered out {filtered_count} URLs, {len(self.discovered_urls)} remaining") + + if not self.discovered_urls: + logger.error("No URLs remaining after filtering!") + raise RuntimeError("No URLs remaining after filtering") + + logger.info(f"Processing {len(self.discovered_urls)} URLs:") for i, url in enumerate(self.discovered_urls[:10], 1): logger.info(f" {i}. {url}") if len(self.discovered_urls) > 10: logger.info(f" ... and {len(self.discovered_urls) - 10} more") - # Fetch phase + # Phase 3: Fetch - download the filtered URLs await self.fetch_all_pages() # Compile and save markdown_content = self.compile_markdown() # Save markdown - markdown_path = OUT_FILE.with_suffix('.md') - logger.info(f"Saving markdown to: {markdown_path}") - markdown_path.write_text(markdown_content, encoding='utf-8') - logger.info(f"Markdown file size: {len(markdown_content):,} bytes") - - -def main(): - parser = argparse.ArgumentParser( - description="Documentation Snapshot Crawler - Extract clean documentation content from websites", - epilog=""" -Examples: - uv run docs-crawler https://docs.example.com - """, - formatter_class=argparse.RawDescriptionHelpFormatter - ) - parser.add_argument('base_url', help='Base URL of the documentation site (e.g., https://docs.example.com)') - - args = parser.parse_args() - - async def run_crawler(base_url: str): - async with DocsCrawler(base_url) as crawler: - await crawler.run() - return asyncio.run(run_crawler(args.base_url)) + if output_path is None: + output_path = OUT_FILE.with_suffix('.md') + else: + output_path = Path(output_path) + logger.info(f"Saving markdown to: {output_path}") + output_path.write_text(markdown_content, encoding='utf-8') + logger.info(f"Markdown file size: {len(markdown_content):,} bytes") -if __name__ == '__main__': - main() + return output_path diff --git a/python/src/scripts/summarizer/doc_dump_summarizer.py b/python/src/cairo_coder_tools/ingestion/doc_dump_summarizer.py similarity index 100% rename from python/src/scripts/summarizer/doc_dump_summarizer.py rename to python/src/cairo_coder_tools/ingestion/doc_dump_summarizer.py diff --git a/python/src/scripts/summarizer/dpsy_summarizer.py b/python/src/cairo_coder_tools/ingestion/dpsy_summarizer.py similarity index 100% rename from python/src/scripts/summarizer/dpsy_summarizer.py rename to python/src/cairo_coder_tools/ingestion/dpsy_summarizer.py diff --git a/python/src/cairo_coder_tools/ingestion/generated/blog_summary.md b/python/src/cairo_coder_tools/ingestion/generated/blog_summary.md new file mode 100644 index 00000000..934ce23b --- /dev/null +++ b/python/src/cairo_coder_tools/ingestion/generated/blog_summary.md @@ -0,0 +1,7239 @@ +# www.starknet.io — Snapshot (2025-10-25) + + +--- +Sources: + - https://www.starknet.io/blog/braavos-bitcoin-lightning-payments-strk/ +--- + +## Bitcoin Lightning Network payments with STRK—now live on Starknet via Braavos | + +Home  /  Blog + +Mar 13, 2025 · 3 min read + +Not even 48 hours have passed since Starknet announced plans to become the first L2 to unify Bitcoin and Ethereum—scaling Bitcoin while expanding its utility. Well guess what? Bit by bit (yes, pun intended), that vision is already turning into reality. + +Today, Braavos is launching a major Bitcoin use case for Starknet. Braavos now enables Lightning Network payments using STRK. With this feature, anyone using a Braavos wallet can pay at any Lightning-enabled merchant—effortlessly, without setting up a separate Lightning wallet or holding BTC. + +## Make crypto payments great again + +While Bitcoin is widely used today as a store of value, its original design also envisioned it as peer-to-peer digital cash. In practice, however, onchain transactions became too slow, expensive, and inefficient for small payments. Starknet aims to scale Bitcoin, making it technically feasible to fulfill this original vision. + +But Starknet wasn’t the first attempt at solving Bitcoin’s scalability problem. The Lightning Network is already making Bitcoin usable for everyday payments, like buying coffee or sending micropayments. Yet, Lightning still comes with hurdles. Users need to set up a separate Lightning wallet, pre-fund it with BTC, and manage liquidity—a process that is complex, adds friction and limits adoption. + +Now, Braavos is eliminating those barriers—making Bitcoin Lightning payments as easy as using any traditional payment app. + +## They accept BTC? You can pay with STRK + +Starting today, Starknet users can walk into any store that accepts Bitcoin Lightning payments and pay instantly—using only STRK and their Braavos wallet. No BTC needed. No extra setup. Just tap and pay. + +At checkout, simply scan the Lightning QR code using the Braavos app and pay with STRK. Behind the scenes, the Atomiq bridge—a fully non-custodial solution—instantly converts STRK to BTC and completes the Lightning payment in real time. The vendor receives BTC instantly, and you’re off—sipping your coffee, paying the way Satoshi intended. + +[https://www.starknet.io/wp-content/uploads/2025/03/Lightning-Payment-1.mp4](https://www.starknet.io/wp-content/uploads/2025/03/Lightning-Payment-1.mp4?_=1) + +## Bitcoin Lightning payments—now built for Starknet + +Let’s break down what makes this different from other Lightning Network payment methods: + +* **No Lightning Setup Required**—Traditional Lightning wallets require users to create an account, pre-fund BTC, and manage liquidity. With Braavos, it all happens under the hood. No setup, no extra steps. +* **Pay with STRK, Not Just BTC**—Instead of requiring BTC to use Lightning, Braavos users can pay directly with STRK. +* **Instant & Low-Cost payments**—Transactions are executed instantly via the Atomiq bridge with minimal fees. +* **Seamless Starknet Integration**—Payments happen **natively on Starknet**, reinforcing its role as the **execution layer unifying Bitcoin and Ethereum.** + +## STRK is now part of the real-world Bitcoin economy + +For Bitcoin payments to succeed, they need to be as seamless as the payment apps people already use. That’s exactly what this integration delivers. It gives STRK real-world utility in the Bitcoin economy. And at the same time, Bitcoin payments become more accessible. Both Starknet and Bitcoin win with this new Braavos feature. + +Bitcoin payments have always had friction. Now, that friction is minimized. This feature doesn’t just improve Bitcoin payments—it expands their usability. And for the first time, STRK is at the center of it. + +#### Download your Starknet Wallet + +Effortlessly Manage Your Assets and Interact With Hundreds of Starknet dApps + +Download Wallet + +## This is how Bitcoin scales + +Crypto payments have always held a lot of promise. With this integration, that promise is finally becoming a reality. + +For the first time, Starknet users can access Bitcoin Lightning payments natively. This isn’t just a technical improvement—it’s a real shift in usability. For Starknet users, it means effortless access to Bitcoin’s payment network. For Bitcoin, it means more real-world transactions and a step toward making crypto payments easily usable. + +Braavos has made Bitcoin payments smoother, but this is bigger than just one feature. This is the Starknet ecosystem leading the way, proving that Bitcoin and Starknet belong together, making the connection between them grow stronger. + +Bitcoin has always been a movement, not just an asset. It set the foundation for decentralization, trustlessness, and self-sovereignty. But over time, Bitcoin’s use cases have narrowed—mostly held as a store of value, rarely spent, and difficult to build on. Starknet is here to change that. + +With this integration, Bitcoin payments become seamless, and STRK gets real-world utility in the Bitcoin economy**.** But more importantly, Starknet is proving its commitment to fulfill its mission and become the execution layer for Bitcoin. The vision is simple: expand Bitcoin’s usability without compromising its core principles—taking it beyond HODLing and into real-world utility. + +And this is just the start. + +## Try it today + +You don’t have to wait—this is live right now. You can now use STRK for instant Bitcoin Lightning payments. + +Download the Braavos Wallet and try it out at any vendor that accepts Bitcoin Lightning payments. + +Users: **Stay tuned** for more Bitcoin-related integrations coming to Starknet on X. + +Developers & Builders: + +* **Explore Starknet’s Bitcoin initiatives** and integrate Bitcoin-based use cases. +* **Build on Starknet**, the execution layer unifying Bitcoin and Ethereum. + +Bitcoin is ready for scale. Starknet is making it happen. + +--- +Sources: + - https://www.starknet.io/blog/altlayer-sn-stack/ +--- + +## AltLayer now supports the SN Stack | Starknet + +Home  /  Blog + +Jan 15, 2025 · 2 min read + +Last week, we announced the launch of SN Stack, making the most battle-tested and top-performant ZK tech stack accessible for all chain builders. But we’re not stopping there; it’s only upwards and onwards for the SN Stack (Starknet Stack) from here on, as we’re now proud to announce a partnership with the all-mighty AltLayer. + +AltLayer is a leading Rollup infrastructure provider with extensive expertise in leveraging restaking. It is now the first external Rollups-as-a-Service (RaaS) facilitating Rollup deployment for those building using the SN Stack. + +## What’s in it for builders? + +What does this collaboration mean for SN Stack chain builders? AltLayer is an implementation provider that offers a Rollup launchpad for builders and developers who desire the easiest, most seamless way to build their custom chain. They are now offering their service using the same ZK tech stack that powers public Starknet. + +Teaming up with AltLayer means builders can launch customized chains powered by the SN Stack while focusing only on their core business, leaving the technical intricacies in the hands of RaaS professionals with an SLA promising an SN Stack-powered Rollup mainnet ready within minutes. + +## Your very own Starknet + +The SN stack enables builders to deploy their very own customized chains while benefiting from the powerful features and constant tech stack optimizations that make public Starknet exceptional. In just a year, Starknet’s capacity increased 12x from 70 to over 800 TPS, fees dropped 100x to less than $0.001, and transactions accelerated by 7x from 15 to just 2 seconds—and this is only the beginning. The coming launch of next-gen prover Stwo will take proving speeds to the next level and unlock client-side proving, which will add privacy features to customized chains. + +[https://www.starknet.io/wp-content/uploads/2025/01/SN-Stack-Leo-vid.mp4](https://www.starknet.io/wp-content/uploads/2025/01/SN-Stack-Leo-vid.mp4?_=1) + +This collaboration with AltLayer, who now offer implementation of the SN Stack among their numerous services, will bring about a wide-spread usage of STARK technology for a variety of use cases, all benefiting from low L1 settlement cost, the highest transaction throughput, and unique features like Native Account Abstraction. + +AltLayer makes it seamless to launch your own customized Rollup powered by the best ZK tech stack around. Thanks to AltLayer, who bring to the table all of their experience and expertise in facilitating successful Rollup launches, more builders will have their very own Starknet. + +Ready to build your custom chain using the SN Stack? Get started today. + +Reach out to AltLayer here: [email protected] + +--- +Sources: + - https://www.starknet.io/blog/starknet-bitcoin-vitalik-reactions/ +--- + +## Starknet over Bitcoin: Vitalik, Dan Held, and Jeremy Rubin react + +Home  /  Blog + +Mar 30, 2025 · 2 min read + +Bitcoin has empowered millions of people around the world to reclaim control over their assets and sovereignty. Yet most Bitcoin today sits static in wallets and exchanges because the network **A.** doesn’t scale and **B.** doesn’t natively support advanced actions beyond buying, selling, and transferring. By settling on Bitcoin in addition to Ethereum, Starknet will lift both of those restrictions to help unleash Bitcoin’s full potential. + +How does Ethereum’s co-founder Vitalik Buterin feel about this move? Or the two Bitcoin OGs Dan Held (GP at Asymmetric) and Jeremy Rubin (Founder of Judica and a Bitcoin core researcher & developer)? The three joined StarkWare CEO Eli Ben-Sasson and CPO Avihu Levy to discuss the vision to scale Bitcoin with Starknet and how it will impact the Bitcoin and Ethereum communities. Below are highlights from the X Space, led by StarkWare’s Head of Ecosystem, Abdelhamid Bakhta. + +## How will Starknet settling on Bitcoin affect the Bitcoin & Ethereum communities? + +Vitalik, Dan Held, and Jeremy Rubin on how Starknet settling on Bitcoin would affect both the Bitcoin and Ethereum communities, and the prospect of enabling the trustless flow of the assets between them. Hint: It could mean greater decentralization of the exchange layer of blockchain, says Vitalik. + +## Native DeFi on Bitcoin? + +L1 is simple and it works—and we want to keep it that way, says Dan Held. Starknet and other L2s, on the other hand, could introduce a world of new DeFi opportunities to Bitcoin: Borrowing, lending, staking, and yield farming, without compromising on security. + +## Greater decentralization of mining pools + +Native DeFi is only the tip of the iceberg of what Starknet—a scalable Layer 2 that enables general-purpose computing—could bring to Bitcoin. Mining pools in the Bitcoin ecosystem, for example, are currently a point of centralization, says Jeremy Rubin. Could Starkent, as an execution layer that unifies Bitcoin and Ethereum, bring greater decentralization to mining pools? + +## **‘**Making crypto payments great again’ + +And let’s not forget about the fundamentals—we *are* scaling Bitcoin, after all. In addition to the new applications Starknet could bring to Bitcoin, its scaling power will also improve existing Bitcoin payments. Vitalik covers the prospect of scaling Bitcoin payments with a proper Layer 2 that satisfies the needed security properties. Hint: ZK all the way. + +## How OP\_CAT opens the door to Starknet on Bitcoin + +Starknet over Bitcoin would be awesome, but how can that technically happen? StarkWare CPO Avihu Levy dives into how the proposed OP\_CAT upgrade to Bitcoin makes it possible. + +## Why Bitcoin? + +“In math we trust.” StarkWare CEO Eli Ben-Sasson discusses StarkWare’s roots in Bitcoin, and how it led him on his path from theoretical computer science to becoming a true believer in blockchain’s transformative potential. + +## The full X Space + +For those of you interested in hearing more of Vitalik, Dan, and Jeremy’s thoughts about the plan to settle over Bitcoin and Ethereum, you can find the entire X Space below: + +--- +Sources: + - https://www.starknet.io/blog/introducing-garden-on-starknet-a-direct-path-for-btc-bridging/ +--- + +## Bridge BTC to Starknet: Introducing Garden + +Home  /  Blog + +Apr 29, 2025 · 2 min read + +We’re thrilled to announce that Garden – a bridge for BTC-native liquidity – is now live on Starknet. This launch creates a direct, streamlined path for Bitcoin to flow into Starknet, focusing on speed, low fees, and minimal trust assumptions. + +## What Sets Garden Apart + +Garden’s integration with Starknet makes it easy for Bitcoin holders to access Starknet while keeping control of their assets. At the same time, it allows developers and DeFi protocols to tap into BTC liquidity, unlocking new possibilities for apps and flows across the Starknet ecosystem. Sending BTC to Starknet is now straightforward, whether using a crypto wallet like Argent or swapping directly on Garden. The entire process is simplified with a real-time system that finds the best route for your transaction, keeping costs low and execution fast, even for larger trades. On Garden, swap BTC, USDC, WBTC, cbBTC, and more from Bitcoin, Base, Arbitrum, Ethereum, Berachain, and Hyperliquid to Starknet in a single click. + + Bridge BTC to Starknet → + +## More About Starknet + +Starknet is a general-purpose L2 ZK-Rollup that operates above Ethereum and allows users to write and deploy smart contracts and interact with other contracts. Starknet produces bundled transactions offchain via STARK proofs, which are then submitted to Ethereum as a single transaction, allowing dApps to scale while benefiting from Ethereum’s security features massively. Starknet will be the first L2 to settle on both Bitcoin and Ethereum, unifying the two largest blockchains on a single layer. As an L2 on top of Bitcoin, Starknet will become Bitcoin’s execution layer, to trustlessly scale Bitcoin to thousands of transactions per second (TPS). + +Explore Starknet’s vision and roadmap to see how this aligns with broader ecosystem growth. If you’re deep into Bitcoin, building the next wave of DeFi, or just excited about where Ethereum is heading, now’s the time to plug in and bridge BTC to Starknet. + +--- +Sources: + - https://www.starknet.io/blog/lombard-brings-bitcoin-to-starknet-through-lbtc-integration/ +--- + +## Bringing Bitcoin to Starknet with Lombard's LBTC + +Home  /  Blog + +May 14, 2025 · 2 min read + +Starknet is proud to announce a strategic partnership with Lombard Protocol, a Bitcoin staking protocol and developer of LBTC. Lombard is bringing LBTC—the leading liquid staked Bitcoin asset—into the Starknet ecosystem, unlocking new earning opportunities and pushing forward a powerful vision: a single, scalable execution layer for both Ethereum and Bitcoin. + +## What is LBTC? + +LBTC is liquid-staked Bitcoin, built on top of Babylon, free to be used across DeFi. Each LBTC token is fully backed 1:1 by real BTC, staked to the Babylon Bitcoin staking protocol. Users obtain LBTC by staking native BTC on the Lombard Protocol, effectively locking their Bitcoin and receiving an equal amount of LBTC in return. This asset can be used for lending, borrowing, trading, and liquidity provisioning across many blockchains, including Ethereum, Base, and Sui. + +## LBTC on Starknet + +Over the coming months, users will be able to stake native BTC for LBTC and bridge LBTC to and from Starknet with ease. Starknet users will gain access to LBTC and Lombard’s DeFi vault through the upcoming integration. This initiative is designed to activate Bitcoin capital within the fast-growing Starknet DeFi ecosystem, offering a secure and seamless experience for both institutional and individual users. + +Institutions will gain a powerful tool to deploy Bitcoin capital across DeFi dApps with greater scalability. Retail users and app developers will benefit from increased liquidity, earn-generating strategies, and new use cases. + +## Lombard and Starknet + +Lombard Protocol’s mission to bring Bitcoin into DeFi aligns perfectly with Starknet’s long-term vision of becoming the execution layer for both Ethereum and Bitcoin. This collaboration represents a key milestone in building a modular, multi-chain DeFi ecosystem, where assets from both chains can flow freely and unlock new possibilities. + +With its focus on decentralization, Starknet is emerging as a natural home for Bitcoin assets in DeFi, offering a reliable foundation for BTC’s thriving in a cross-chain, modular ecosystem. + +**Stay tuned for the integration** + +--- +Sources: + - https://www.starknet.io/blog/starknet-bitcoin-scaling/ +--- + +## Starknet scaling Bitcoin: The first L2 to settle on Bitcoin & Ethereum + +Home  /  Blog + +Mar 11, 2025 · 7 min read + +Bitcoin is more than just a financial asset: It’s a movement rooted in individual sovereignty and the separation of money from the state. Over the past 16 years, it has empowered millions of people around the world to reclaim control over their assets, catalyzing a revolution in how we think about money and trust. And yet, most Bitcoin today sits static in wallets and exchanges, constrained by the limitations of the network’s original design: a lack of scalability and an inability to natively support applications beyond simple buying, selling, and transferring. + +Starknet is embarking on a journey to lift both of those limitations and unleash Bitcoin’s full potential, all while preserving its core principles. Developed in part by the inventors of STARK proofs, Starknet will become the first Layer 2 to settle on both Bitcoin and Ethereum, unifying the world’s largest blockchains on a single layer. The goal is ***to serve 1 billion Bitcoin users*,** introducing improved UX, scale, and liquidity—all without compromising on security or decentralization. + +Efforts across the Starknet ecosystem are already underway to prepare the grounds to achieve this goal. Alongside the continued research and advocacy for OP\_CAT, the proposed Bitcoin upgrade that would pave the way for natively bridging Starknet to the network, the following announcements were just unveiled: + +* **Xverse integration**: The leading Bitcoin wallet, Xverse, will integrate with Starknet, enabling the use of Bitcoin assets on Starknet for the first time. +* **BTCFi Season**: The Starknet Foundation is introducing BTCFi Season, a program that will introduce a range of opportunities to put your Bitcoin to work through Starknet. +* **Strategic Bitcoin Reserve**: StarkWare, the company behind the STARK proof that contributes to the development of Starknet, is a Bitcoin-standard company and now has a Strategic Bitcoin Reserve (SBR), holding a growing portion of its treasury as BTC. +* **Lightning Network payments:** Anyone using the Braavos wallet mobile app can scan a QR code and make instant payments using STRK at any vendor that accepts Lightning Network payments. + +Now, let’s dive deeper into the vision for Starknet over Bitcoin. + +## The Starknet vision for Bitcoin + +### The challenge + +Bitcoin set the bar for the core values that make blockchain transformative: decentralization, trustlessness, and censorship-resistance. The vast majority of Bitcoin, however, isn’t being used for anything beyond buying, selling, and long-term investing (HODLing). + +While some investors view Bitcoin as digital gold—a long-term hedge against inflation and economic instability, rather than as an asset to actively trade or leverage—there is a demand for utilizing Bitcoin for purposes beyond that. Think, for example, of using Bitcoin as collateral to buy assets outside the digital domain or to earn the way you do with many other assets. Interviews and research conducted by StarkWare—the company that initially developed the zero-knowledge (ZK) technology that powers Starknet—identified three main barriers to doing so: + +* **Limited Bitcoin functionality:** The Bitcoin network doesn’t natively support complex applications, restricting it primarily to simple transactions and holding (HODLing). +* **Security & centralization risks:** Applications that enable DeFi actions outside of Bitcoin often involve custodial or third-party platforms that introduce risk (e.g. the Celsius, BlockFi, and FTX collapses). +* **Slow, costly transactions:** Bitcoin’s block times and fees can deter everyday transactions or more sophisticated onchain use cases. + +Starknet will make these challenges obsolete. + +### The Starknet solution + +As a Layer 2 on top of Bitcoin, Starknet will become **Bitcoin’s execution layer,** with the goal of trustlessly scaling Bitcoin from 13 transactions per second (TPS) to thousands**.** Because Starknet will enable native expressiveness on Bitcoin at scale for the first time, it will open the floodgates to more complex applications that were previously not supported on Bitcoin. + +With its battle-tested technology, Starknet will bring Bitcoin: + +* **Layer 2 scaling:** Starknet scales blockchain by executing many transactions offchain and bundling them into a single STARK proof that attests to their validity on L1. +* **STARK proofs:** These proofs are quantum-resistant and require no trusted setup, ensuring trustlessness and high security for all Bitcoin-centric activities on Starknet. +* **Instant & cheap transactions:** Starknet transactions finalize in seconds and cost fractions of a cent, addressing Bitcoin’s scalability bottleneck. +* **Expressiveness:** Developers will be able to build a wide variety of DeFi and other complex applications on Bitcoin through Starknet’s smart contract functionality. Applications such as staking, borrowing and lending, leveraged trading, and yield farming will become natively possible on Bitcoin via Starknet. + +With these advantages and more, Starknet is fully equipped to scale Bitcoin with integrity while expanding its utility. + +### Long-term impact + +By scaling Bitcoin and enabling more sophisticated applications on the Bitcoin blockchain in a trustless environment, Starknet will unleash the true potential of the world’s original blockchain. This will result in: + +* **Global reach:** The goal is for Starknet to serve **a billion Bitcoin users**, bringing mainstream financial-grade functionality to the Bitcoin network. +* **Security & decentralization:** Starknet enables Bitcoiners to do more with their Bitcoin on Starknet without compromising on security, as Starknet progresses toward its own decentralized operation. +* **Unified blockchain ecosystem:** With Bitcoin and Ethereum consolidated on Starknet’s execution layer, the broader blockchain community can enjoy faster, cheaper, and more secure onchain interactions. + +### Why Starknet? + +After years of operating on Ethereum, Starknet is the cheapest Layer 2 with Ethereum data availability (DA) and near-instant transaction confirmation, powered by the most advanced ZK tech stack in the blockchain industry. With the following advantages and more, Starknet is fully equipped to bring massive scale to Bitcoin while preserving its core principles: + +* **Proven track record:** The technology behind Starknet has already processed millions of transactions on Ethereum, with cumulative trading of +1.3 trillion USD. +* **Built by the original creators of STARKs:** The STARK proofs used on Starknet were developed by the original inventors of the technology itself. +* **Enhanced user experience:** Native account abstraction means more familiar login methods (fingerprint, face ID), and other features that simplify crypto usage. + +### Breakthrough research on Bitcoin scaling + +The StarkWare team that originally pioneered the technology behind Starknet has invested time and resources into Bitcoin research to promote Bitcoin scaling, bolstered by its OP\_CAT research fund. These efforts have already yielded notable achievements. + +Collider-script, for example, introduced a method for enforcing covenants on Bitcoin outputs without requiring any changes to Bitcoin. Covenants are one of the primary components necessary for bringing smart contracts-and therefore expressiveness-to Bitcoin. This was followed by the demonstration of a demo bridge covenant on Bitcoin, which aims to be the foundation of a production-grade bridge from Bitcoin to Starknet. + +In an open-source effort, led by Weikeng Chen and Pinghzou Yuan, StarkWare has already verified the first-ever ZK proof on Bitcoin’s Signet test network using its STARK verifier. + +### Why now? + +While Starknet started by settling on the Ethereum blockchain, its roots in Bitcoin are deep—pre-Ethereum deep. It all started when Professor Eli Ben-Sasson, CEO and Co-Founder of StarkWare, spoke at the Bitcoin Conference in San Jose back in 2013. It was then that he first introduced the idea of using ZK proofs (specifically, the tech later called zk-STARK) to scale Bitcoin. + +Since then, Starknet emerged to bring massive scalability to Ethereum with STARK proofs as its core security technology. Now, as Bitcoin sees record global interest and demand, the time has come for Starknet to step up to its next challenge. + +## How will this be achieved? + +### The Starknet experience on Bitcoin now + +Bitcoin users deserve to be able to utilize their Bitcoin with confidence, and the highest level of security and decentralization. Starknet stakeholders have been and will continue to educate about and advocate for OP\_CAT, a proposed Bitcoin upgrade that would, as StarkWare has identified, open the door to natively settling Starknet on Bitcoin. Even before the OP\_CAT upgrade, however, efforts will be made to enable using Bitcoin on Starknet with the following kinds of bridges: + +#### Federated model (multisig) + +In the federated model of bridging Starknet to Bitcoin, a group of co-signers collectively safeguards the Bitcoin tokens locked and minted on Starknet through a multisig. The federation is accountable for minting an identical amount of wrapped Bitcoin on Starknet as the amount being bridged. The multisig bridge enables lower fees and elevated UX, but requires that the majority of the signers are honest participants, limiting network liveness. + +#### BitVM + +BitVM is the most secure way to bridge Bitcoin without OP\_CAT. Instead of working with a multisig, BitVM requires that only one of the operators is honest. It enables this by enforcing the logic with a dispute-resolution mechanism powered by cryptographic proofs. + +### OP\_CAT readiness + +The OP\_CAT soft fork, if it passes, will open the door to covenants and native L2 scaling and expressiveness on Bitcoin, empowering the world’s first blockchain to live up to its potential to disrupt traditional financial systems. + +Covenants enable programmable spending rules and, therefore, native smart contracts. Together with STARK proofs, they make it possible to build a fully trustless, native bridge from Bitcoin to Starknet. This native bridge will function without any additional operators or trust assumptions, providing Bitcoin users with the maximal level of security, decentralization, and self-custody. + +A more technical, deeper dive into how Starknet will settle on Bitcoin will be shared in the coming days. + +## Next steps + +In the next few months, several products and partnerships will pave the way for the best possible L2 experience for Bitcoiners on Starknet. These include offerings and incentives that users will be able to enjoy, as well as announcements on major milestones in the research being conducted: + +* **Partnerships:** Starknet stakeholders are forming alliances with key Bitcoin ecosystem players, including wallet providers and researchers. +* **New products & offerings:** Multiple new products and retail offerings will be introduced in the coming months to encourage the adoption of Starknet for Bitcoin. +* **BTCFi Season:** The Starknet Foundation is introducing BTCFi Season, a program designed to open up a range of opportunities to all Bitcoin users. This program will incentivize Bitcoin holders to participate in DeFi on Starknet, allowing users to put their Bitcoin to work in a wide variety of ways. Sign up with your email to be among the first to know when the program goes live. +* **Research & Education:** Ongoing efforts focus on advocating for Bitcoin upgrades like OP\_CAT and exploring how STARK proofs can scale Bitcoin’s functionality. StarkWare launched the OP\_CAT Research Fund for this purpose. + +## What should you do now? + +Starknet stakeholders are already moving quickly to make Starknet the first Layer 2 to unify Bitcoin and Ethereum without compromising their integrity. What should you do in the meantime? + +Start by setting up a Starknet wallet and check out the Bitcoin DeFi opportunities on BTCFi Season. Browse Starknet’s apps—exactly the kinds of apps that Starknet will make possible on Bitcoin. If you’re a builder who is excited about Starknet as the unifying execution layer for Bitcoin and Ethereum and would like to build the next killer app, check out the Starknet docs to get started. + +Follow Starknet on X to stay updated on all upcoming news. + +--- +Sources: + - https://www.starknet.io/blog/decentralized-starknet-2025/ +--- + +## Starknet’s Decentralization Roadmap in 2025 + +Home  /  Blog + +Feb 26, 2025 · 5 min read + +Blockchain makes it possible for people to control their assets and transact directly with others on a trustless, secure, and censorship-resistant network. That ideal has the potential to transform entire industries, and it can only be achieved on blockchains that are truly decentralized. Blockchains dominated by a single party or conglomerate don’t *really* have an edge over traditional, centralized networks. + +With the goal of bringing blockchain’s promise to everyone, Starknet is on the path to becoming the first fully decentralized Layer 2 (L2) that massively scales Ethereum. The recent launch of the first phase of staking on Starknet was a leap toward greater decentralization. This year, efforts to enhance Starknet’s decentralization will ramp up on top of continued performance optimizations. + +## Decentralized Starknet in 2025 + +Ethereum was the first blockchain to enable general-purpose computing. It earned its reputation for staying true to the first principles of blockchain: decentralization and security. As a Layer on top of—and thus an extension of—Ethereum, Starknet must also be decentralized and secure. + +The terms “decentralization” and “security” are often used interchangeably. While it’s true that decentralization enhances security, we distinguish between the two in this post. That’s because, unlike other L2 rollups, Starknet has had its ironclad security technology—STARK proofs—in place from the beginning. There has never been a state update approved on Starknet that wasn’t validated by a proof. That means it’s virtually impossible for an invalid transaction to be processed on Starknet. This post will zero in specifically on Starknet’s decentralization journey, and the ways in which it will progress in 2025. + +Starknet’s road to decentralization runs on three main lanes: + +* **Staking:** Building economic security on Starknet toward the decentralized operation of its Proof-of-Stake (PoS) consensus mechanism + +* **Operation:** The decentralization of Starknet’s operation + +* **Governance:** The independence of the Starknet Security Council + +Let’s dive into Starknet’s progress in each of these lanes, and what’s coming up. + +#### Breaking speed records with 992 peak TPS + +Build Lightning-Fast, Scalable dApps on Starknet + +Explore Starknet + +##### + +### Staking + +Crucial to the decentralized operation of Starknet is the acquisition of economic security on the network, a process that is already under way. At a high level, here’s what this means: + +Starknet uses Proof-of-Stake (PoS) as its mechanism for preventing Sybil attacks, in which a single entity or group of entities creates multiple validators to gain disproportionate influence over the network. PoS prevents these attacks by requiring validators to stake tokens. This ensures influence over the network is proportional to the economic cost of acquiring and risking tokens, rather than the number of validators created. + +On Layer 1 PoS protocols, staking starts from genesis, and the consensus layer’s security generally improves with its economic value. For rollups, such as Starknet, the story is different. + +Rollups inherit the security of their settlement layer and accrue economic value even if they don’t decentralize their operation. This dynamic provides an advantage to rollups that *are* on the path to decentralizing their protocol, such as Starknet. That’s because it opens the door to accumulating high amounts and a wide distribution of stake before the decentralization of the protocol. This sets decentralized, public Starknet up in a way that prevents the disproportionate influence of a select few on the network, fostering its stability and a wide distribution of validators. + +As such, Starknet is first gathering *economic security* through staking, and only afterward allowing for decentralized operation of the protocol. + +To this end, Starknet staking began as an *application*, decoupled from consensus—Phase 1 of Starknet staking (Staking v1) went live on November 26, 2024, and has been accumulating economic security ever since. To date, more than 170 million in STRK is being staked by 63,000 delegators and 106 validators. + +Stake your STRK → + +Staking v2 will enter mainnet in Q2 of 2025, coupling staking rewards to stakers attesting blocks. Staking v3 will enter mainnet in Q4 of 2025, coupling staking rewards to block validation. Finally, Staking v4 will make validators fully responsible for maintaining and securing the network by producing, attesting, and proving blocks. + +Each stage of staking contributes to building economic security and opens the door to the decentralized operation of the Starknet protocol. + +### Operation + +In addition to economic security, the decentralization of Starknet’s operation requires a fully functional open-source stack with end-to-end functionality. Enter the SN Stack, which has just recently been made available and enables anyone to use the parts that power Starknet. + +The present architecture of public Starknet relies on the open-source Stone prover and a closed-source sequencer, which are complemented by the open-source Madara and Katana sequencers. Throughout 2025, public Starknet will migrate to a newer stack, founded on the next-gen Apollo sequencer and the Stwo prover, both of which will be open-source. Stwo will make proving on Starknet much more efficient. + +The next step toward the decentralized operation of Starknet will be the decentralization of the consensus layer. This means validators will vote on each Starknet block, and only a sufficient quorum of such votes will finalize a new block. Decentralized consensus is planned to go live on mainnet at the end of 2025. Here is the game plan in broad strokes: + +1. Starknet v0.14.0: Launch of the distributed sequencer architecture comprised of an internal network of 3f+1 nodes running consensus and taking turns building and proposing blocks +2. Production release of the next-gen-sequencer for anyone to run +3. Deployment on Testnet(s) +4. Deployment on Mainnet + +We have omitted subtler milestones pertaining to client diversity, which is crucial for a robust network. We’ll just say there are three *additional* full nodes that are presently integrating consensus and block proposal functionality: Juno, Pathfinder, and Madara (which needs only consensus). + +### Governance + +Given a fixed protocol, there are “meta” matters pertaining to protocol changes. Governance of such matters is a difficult problem without any canonical solutions. For L1 networks, “the protocol” is practically defined by the majority of nodes in the network: If most nodes collaboratively modify their clients, the network remains the same while its protocol changes. Hence, L1 networks can have “informal” governance—nothing is set in stone. + +Rollups, on the other hand, have core contracts on their settlement layers. Even if all L2 clients were modified, the core contract itself can only change through action on the settlement layer. Hence, rollup governance requires explicit permissioning for modifying L1 core contracts. + +The Starknet Security Council is a governance mechanism that decentralizes control over core contracts (both on L1 and L2) pertaining to state updates, staking, and STRK minting (which is managed by smart contracts, unlike Ethereum, where rewards are implemented at the client level). + +Moreover, the Security Council’s capacity to perform L1 state updates allows it to bypass consensus in case of censorship of L1/L2 messages. Thus, the Security Council facilitates censorship resistance in addition to its governance functions. + +A Security Council is a first step toward the decentralized governance of a decentralized Starknet. However, the challenge is broader than formal control core contracts. The governance question has social and technical aspects that require much thought. Improving the decentralization of the mechanism is a core goal of decentralized Starknet. + +## Other features + +While big decentralization moves are set to be made on Starknet this year, other features that aren’t decentralization-related, such as additional fee reductions and UX/DevX improvements, will also be launched. + +**v0.13.4:** This version upgrade introduces: + +* **Stateful compression:** Will reduce fees + +* **L2 gas price:** Introduces fixed price, denominated in fri, for a single unit of L2 gas until fee market in v0.14.4; it decouples L2 computation fees from the L1 gas market + +* **Try/catch for function call failures** + +* **Cairo-native (Sierra → LLVM):** Will boost performance, and potentially TPS + +**v0.14.0:** In addition to the distributed sequencer and potentially Stwo integration, this version will introduce: + +* **2-second blocks, mempool, & fee market:** Better UX, DevX + +For a deeper dive into upcoming features, read the Starknet v0.13.4 pre-release notes, with more to come on v0.14.0. + +## Conclusion + +The journey toward decentralized, scalable blockchain is a monumental challenge, but it must be achieved if blockchain is to achieve its full potential. Starknet stands at the forefront of this mission, proving that scalability and decentralization can coexist without compromise. By advancing staking, open-sourcing its stack, and progressing toward decentralized governance, Starknet is not only shaping its own future but also setting a benchmark for what L2s can achieve. + +Stay tuned for updates about Starknet’s decentralization journey on X. + +--- +Sources: + - https://www.starknet.io/blog/broly-trust-minimized-bitcoin-inscriptions-directly-from-your-starknet-wallet/ +--- + +## Broly – Trust-minimized Bitcoin inscriptions from Starknet wallet + +Home  /  Blog + +May 19, 2025 · 5 min read + +Broly is a POC that enables users to create Bitcoin inscriptions via Starknet without owning BTC or interacting directly with the Bitcoin network – securely, easily, and in a trust-minimized way. Broly runs an order book of inscription requests on Starknet, handles the Bitcoin transactions in the background, and uses smart contracts to prove that the transactions are valid. + +Broly was developed by the Exploration team at StarkWare – the technology company that is Starknet’s main contributor – for the benefit of the Bitcoin dev community. Broly enables Bitcoin devs to trustlessly create inscriptions in their applications with the best UX possible, paving the way for devs to build many new experiences and use cases. Broly also demonstrates the benefits of the Utu Relay and Raito open source libraries, which are discussed below. + +## How Broly works + +Broly allows users to prove statements about inscriptions, including the validity of inscribed data and the ownership of an inscription. For those who are less familiar with Bitcoin’s ecosystem, inscriptions are similar to NFTs – data attached to satoshis, which are unique and numbered. The owner of a satoshi also owns the data that is inscribed on it. The Broly experience for inscriptions is designed to resemble the simplicity and freedom of applications like pump.fun, a Solana-based platform that allows users to easily trade and create assets, tokens or NFTs. In this way, Broly allows app devs to easily build pump.fun experiences for Bitcoin with inscriptions. + +To use Broly, the requester, who doesn’t need any BTC on the Bitcoin network, broadcasts a request to get their data inscribed on Bitcoin. A submitter running the inscriber service accepts the request, inscribes the data on Bitcoin, and transfers it to the requester’s Bitcoin address. The submitter can then submit the inscription and transfer transactions to the Broly contract on Starknet and obtain full verification of the validity of the transaction’s execution, transaction inclusion in the block, and inclusion of the block on the canonical Bitcoin chain. + +## Use cases for Broly POC and related dev libraries + +The capabilities unlocked by Broly’s validation of certain statements about Bitcoin transactions and Bitcoin wallets are vast. This is thanks to a powerful library written in Cairo and deployed on Starknet called Utu Relay. Utu Relay, created by web3-focused company LFG Labs, is a smart contract that enables verification of Bitcoin transactions and events. Outside of Utu Relay, there is no other provable method of verifying transactions on Bitcoin except on Bitcoin itself. + +Through Utu Relay, users can submit the headers of the canonical Bitcoin chain and dispute them with a longer chain that comprises more proof of work. Using Merkle proofs, users can also write a contract that will check that a transaction is indeed part of a block. In this way, Utu Relay allows for optimistic disputes. This system will eventually minimize trust when rewards for disputing “bad” chains are implemented for Utu Relay. + +Utu Relay functions like a storage proof and allows different properties of the Bitcoin blockchain to be queried. For example, a user can confirm that someone is the owner of a particular Broly-created inscription using Utu Relay. The tool can also be used to prove solvency, the balance or activity history of a wallet, or a wallet’s history for the purpose of airdrops. Utu Relay can also be used to give early platform access to wallets that have made transactions in multiple ecosystems, not just Bitcoin. Using Utu Relay, for example, a user could prove that he or she had made over 100 transactions cumulatively on Ethereum and Bitcoin by early 2017. OG vibes! + +Another use case is a project in development that allows users to mint Bitcoin badges. This experimental project, built on top of the Broly and Utu Relay infrastructure, allows users to create digital badges based on provable facts or milestones from their historical Bitcoin transaction activity. For instance, a badge might certify that a wallet was active before a certain date or interacted with a specific type of protocol. The key innovation is that these badges are not self-claimed; they can be trusted, as they are based on cryptographic proofs that Utu Relay helps verify. In addition to being great fun, these badges can assert credibility and could be used as collateral for loans, to prove solvency, and more. + +Another useful open source library that Broly is based on is Raito, a Bitcoin consensus light client written in Cairo and developed by the StarkWare Exploration team, which implements the same validation logic as Bitcoin core. Raito is a way to run Bitcoin’s consensus rules in a provable way on Starknet by providing a state between two checkpoints. It allows a system to verify Bitcoin state transitions – like block headers, Merkle roots, or UTXO status – directly within a smart contract on Starknet, eliminating the need for centralized oracles or trusted relayers. + +With Raito, instead of a user needing to trust that someone gave them the correct Bitcoin chain state, or re-run the entire transaction history of Bitcoin, the user can verify a STARK proof. Because Raito compresses Bitcoin’s block validation quickly and trustlessly, verification of the proof is faster than the reexecution of the computation. In the future, this could be a game-changer for building faster syncs among nodes, which currently require hours or even days to sync; making Bitcoin light wallets faster and more secure; and even offering meta-protocol indexers, such as Ordinals, RGB, or Taproot Assets, a decentralized indexing model whereby different clients could verify inscriptions or asset states without rerunning full chain validation themselves. + +## Broly as part of Starknet’s Bitcoin vision + +While Bitcoin has revolutionized the way people think about money and trust, today most BTC sits static in wallets and exchanges, constrained by the network’s lack of scalability and inability to natively support complex applications. Starknet seeks to unleash Bitcoin’s full potential, while preserving its core principles. As a Layer 2 above Bitcoin, Starknet will become Bitcoin’s execution layer, aiming to bring and serve one billion Bitcoin users, introducing improved UX, and trustlessly scaling Bitcoin to thousands of transactions per second (TPS). In the same way that Starknet has brought Ethereum massive scalability with STARK proofs, Starknet aims to bring Bitcoin the same benefits with zero compromises on security and decentralization. + +Starknet’s development of the Broly POC showcases its Bitcoin integration vision, as Broly allows Starknet to work seamlessly with Bitcoin, without requiring users to own BTC or Bitcoin wallets, or even operate on the Bitcoin network. Now it is open for Bitcoin app devs who want to provide their users with rich experiences on Bitcoin without needing to worry about scale, trustlessness and security. + +## Final thoughts + +The Broly POC brings the concept of storage proofs to Bitcoin on Starknet and it can inspire many interesting use cases for teams that are interested in building on Bitcoin, but have been stymied by the network’s limitations. If you are a developer or a builder looking to start building on Bitcoin, the possibilities with Broly, and the underlying Utu Relay and Raito libraries, are endless. + +To learn more about using Broly, check out the full Broly demo video below, as well as the relevant Broly, Utu Relay, and Raito Github pages. The StarkWare Exploration team’s Github site, Keep Starknet Strange, is the best place to learn about all the team’s exciting projects. You can also check out Starknet’s devs hub and dApps ecosystem. Also, be sure to follow Starknet on X for the latest news and announcements. Lastly, delve into Starknet’s vision for Bitcoin integration. + +--- +Sources: + - https://www.starknet.io/blog/starknet-ecosystem-report-2025/ +--- + +## The State of the Starknet Ecosystem 2025 | Starknet + +Home  /  Blog + +Jan 13, 2025 · 5 min read + +The past year was one of tremendous growth in the number of projects, tools, and dApps built on Starknet alongside a definite evolution of Starknet’s ecosystem, displaying new use cases that broaden Starknet and single it out as a hub for innovation across Layer 2 (L2) solutions, and blockchains more generally. + +This report will present the state of the Starknet ecosystem as it enters 2025. It will showcase the evolution of the Starknet ecosystem over the last year while also analyzing different trends and causes behind the changes to the ecosystem. It concludes by highlighting several emerging themes that are shaping the ecosystem’s trajectory into 2025. + +## General growth of the ecosystem + +In 2024, the Starknet ecosystem grew in projects by 168%, going from 72 user-centric projects in November 2023 to 193 projects by November 2024. That’s 121 brand-new dApps and tools for Starknet users, not even mentioning new developer tooling projects. + +This general growth in projects could be attributed to several grant programs allocated by the Starknet Foundation and to constant optimizations to Starknet’s infrastructure, allowing developers and builders to build whatever they will on Starknet. + +#### Be part of Starknet's ecosystem in 2025 + +Build on one of the fastest growing L2 with better UX and blazing fast txs + +Build on Starknet + +##### + +## Game on: Categories with the biggest growth + +### **Gaming boom** + +From 4 to 51 projects in a year, the growth in gaming projects this past year was the most significant expansion in our ecosystem, making it the largest category in our 2024 ecosystem mapping, a growth we expect to continue in 2025. This growth solidifies Starknet’s status as a fertile ground for onchain gaming, and also reflects a growing developer and user interest in onchain gaming. + +This phenomenal growth can be attributed to: + +1. **Native Account Abstraction:** Starknet has native AA, which developers have recently leveraged extensively to provide a seamless Web2-like UX experience essential for gaming. Some of the features allowed by native AA are passkeys, which enable you to use your wallet without a seed phrase; session keys, which let you start a long session without having to sign each and every transaction; and paymaster, which enables users to interact with Starknet without paying any gas fees or having tokens in their wallets. The Cartridge controller implements all these features, letting you onboard an onchain game by simply creating an account with one-click and start playing without any interruptions. +2. **Most performant L2:** Starknet currently has the highest throughput and among the lowest fees across all L2s, both essential for immersive, real-time games. +3. **Developer-friendly tooling:** Out of 47 new gaming projects this year, at least 29 are powered by Dojo, a game engine and toolchain for developing fully onchain provable games. +4. **Grants from the Starknet Foundation:** SNF has generously backed many gaming projects through its Seed Grant Program and its gaming-centered Propulsion Pilot Program. You should definitely check the amazing work done by grant recipients XAR. + +## Explore games on Starknet + +### Focus Tree + +A web3 focus app to help you spend less time on your phone by growing a virtual garden. + + Play games + +### **Other notable growth areas** + +#### 20 new projects in “Other DeFi Protocols” + +The expansion in this diverse category was brought about by the constant optimizations to Starknet’s infrastructure, best-in-class UX, and SNF’s grant programs. + +#### “NFT-Degen-Social” +16 new projects + +The growth in this community-centered category is due to a sentiment shift in how the crypto sphere views Starknet with a recent flourish in degen culture on Starknet. For example, check out the memecoin platform Unrug. + +#### 6 more wallets + +In 2023, Starknet only had its two native wallets, Argent and Braavos, and a Metamask snap. During 2024, 9 different wallets, including notable additions like Keplr and Ledger, have decided to integrate with Starknet. This growth reflects Starknet’s appeal and maturity in the eyes of wallet providers, who sense its potential for user onramp. + +## New categories adding some flavor + +The Starknet ecosystem expanded its scope in the past year with the introduction of two entirely new categories. We expect these categories to further expand in 2025: + +### CEXs + +The launch of the STRK token in February 2024 has attracted major centralized exchanges, including Binance and Crypto.com, among others, to integrate with Starknet, making it easier for a broader user base to onramp to Starknet. + +### AI + +The integration of AI within the Starknet ecosystem reflects a broader trend of exploring the potential of combining AI’s analytical capabilities and automation with blockchain’s transparency and security. This combination is particularly interesting in the context of Starknet’s use of validity proofs. We’ll mention some exciting AI projects later in this report. + +## Trends in ecosystem evolution + +The evolution of Starknet’s ecosystem the past year has been shaped by several noticeable trends: + +1. **Expansion of use cases:** Starknet has evolved from primarily focusing on AMMs and DeFi tools to hosting a wide array of dApps, including gaming, AI, and social projects. This expansion reflects its growing maturity as a network and its appeal to developers from various industries. As of today, there’s quite a lot you can do on Starknet: Native STRK staking and liquid staking with Endur and Nimbora, onchain gaming with Realms.World, prediction making on various topics with Raize Club, providing funds for liquidity pools with Ekubo and Haiko and creating a Starknet ID with StarknetBro. +2. **Integration with centralized systems:** The addition of CEX support for STRK indicates a bridging of the gap between decentralized and centralized finance. By integrating with CEXs, Starknet is lowering the barriers and making it easier for the general public to onboard and join the ecosystem. We might also see major bridge services joining in soon enough so stay tuned. +3. **Enhancement of tools:** Tools and dashboards have evolved from basic utilities to include analytics and portfolio management. Check out Dune and Argent Portfolio. +4. **DeFi diversification:** Beyond traditional AMMs and money markets, DeFi protocols on Starknet now encompass niche financial services like Layer Akira and Raize Club, reflecting maturation in financial innovation. +5. **DeFi Spring Program:** Most of the DEXs and Money Markets in our ecosystem participate in the DeFi Spring Program, which boosts the DeFi protocol’s liquidity and incentivizes liquidity providers by making them earn more. + +## Emerging themes + +Several themes have started gaining momentum over the past year, they’re here to stay and will shape the direction of the ecosystem in the year ahead: + +1. **AI agents:** Starknet is on par with other chains integrating AI with several upcoming verifiable agents by Giza and the multi-agent framework eliza. +2. **Gaming renaissance:** Starknet is clearly establishing itself as the central hub for onchain gaming. +3. **DeFi momentum:** DeFi is also experiencing a high point with new projects and growth. +4. **Degen culture:** Excellent vibes and memes on Starknet with degen culture on the rise. +5. **Broader accessibility:** The inclusion of major CEX players and wallets, such as Ledger and Keplr, makes onboarding easy for mainstream adoption. +6. **Staking:** Phase 1 of STRK staking launched recently, introducing new utilities to the STRK token and marking another big step in Starknet’s journey toward full decentralization. +7. **SN Stack:** The tech stack behind Starknet is now publicly available for apps to build their own custom chains using the best zero-knowledge technology out there, choosing between three different flavors—StarkWare Sequencer, Madara, and Dojo. + +## Wrapping things up + +2025 is here. It’s clear that the previous year has been pivotal for the Starknet ecosystem, defined by more than just massive growth in project numbers. The gaming boom, STRK staking, DeFi momentum, and degen vibes are all signs of an ecosystem ready to take center stage in 2025. Significant shifts, such as integrations with CEXs, more wallet providers, and the SN Stack, demonstrate that the Starknet ecosystem is spreading and will reach more users. The next wave of blockchain innovation will definitely come from the Starknet ecosystem. + +--- +Sources: + - https://www.starknet.io/blog/ordinals-runes-and-the-future-of-bitcoin-l2s/ +--- + +## Ordinals, Runes and the Future of Bitcoin L2s | Starknet + +Home  /  Blog + +Share this post: + +Mar 23, 2025 + +In this conversation, Xverse CEO Ken Liao, team member Yan, and Francis from StarkWare discuss the rapid evolution of the Bitcoin ecosystem. They explore how Xverse became the first wallet to support Ordinals, the rise of Runes, and what the future holds for Bitcoin Layer 2s. The discussion also covers the technical foundations of Ordinal theory, the challenges and promise of Runes, and how Starknet’s integration with Xverse opens the door to smart contracts, DeFi, and scalable apps on Bitcoin. This is a deep dive into how Bitcoin is becoming more programmable while staying true to its core values. + +Learn more about Starknet's Bitcoin vision → + +--- +Sources: + - https://www.starknet.io/blog/stark-spaces-the-diverse-flavors-of-the-sn-stack/ +--- + +## The SN Stack | Starknet + +Home  /  Blog + +Share this post: + +Jan 26, 2025 + +The discussion explored the SN Stack (Starknet Stack), a robust framework comprising foundational components that power the next generation of appchains. Participants delved into the unique characteristics of three distinct implementations: StarkWare’s stack, known for its reliability and production history; Madara, an open-source solution enabling developers to launch customized L2 chains; and Dojo, optimized for fully onchain game development. As fully onchain games push the limits of performance, execution sharding, and fractal scaling emerged as critical innovations, enabling massive computational scalability while preserving user experience. + +The conversation also highlighted the transformative potential of open-source solutions, with Madara and Dojo empowering developers to customize and create seamlessly. Interoperability and privacy were emphasized as key areas of development, with efforts focused on enabling secure, efficient communication between chains. Client-side proving was noted as a significant advancement, offering both privacy and computational efficiency for applications. Looking ahead, the panelists painted a compelling vision for appchains, emphasizing their ability to unlock opportunities for scalability, customization, and seamless user experiences. Developers interested in building with Madara, Dojo, or StarkWare’s stack are encouraged to explore these tools and join the growing Starknet ecosystem. + +Learn more about the SN Stack → + +--- +Sources: + - https://www.starknet.io/blog/sn-stack-announcement/ +--- + +## SN Stack Is Now Publicly Available | Starknet + +Home  /  Blog + +Jan 8, 2025 · 4 min read + +We’re beyond excited to finally announce the launch of SN Stack—empowering everyone to build their own custom chains using the most performant, reliable, and cost-efficient zero-knowledge tech stack, powering public Starknet and many other projects. + +[https://www.starknet.io/wp-content/uploads/2025/01/SN-Stack-Leo-vid.mp4](https://www.starknet.io/wp-content/uploads/2025/01/SN-Stack-Leo-vid.mp4?_=1) + +## How we got here + +STARK technology has been providing massive blockchain scalability for over four years, starting with powering production-grade dApps for well-known companies, like dYdX, Immutable, and Sorare. Building on this extensive experience, the same technology has evolved to serve the most performant and cost-effective general-purpose Validity Rollup in production: Starknet.  + +The heavily battle-tested tech stack that powers Starknet was then adopted by Paradex, the very first ZK appchain, for building its own chain—a crypto-derivatives exchange. Paradex is leveraging Starknet infrastructure to serve 2,356 users across 75 markets, with a total value locked (TVL) of 25 million dollars since its launch in July 2023. + +STARK technology has been a key driver in the success of these projects, and the Starknet tech has become so performant and battle-tested that collective efforts have been made to open up this offering to as many projects as possible. Now, any project can leverage the tech powering Starknet to create its own app-specific chain. This is the new SN Stack (Starknet Stack). + +## Your very own Starknet + +With SN Stack, projects gain access to the advanced scalability, security, cost-efficiency, and reliability of Starknet’s heavily battle-tested technology, which they can tailor for their unique use cases. This launch represents a significant step towards making STARK technology widely accessible, enabling chains to combine high performance with the modularity and freedom to customize parameters and brand their platforms.  + +## ZK tech—done right + +Currently, there are only a few ZK tech stacks in the market that allow apps to build their own chains—none of which are as cost-effective, performant, and versatile as the SN Stack. But even more importantly, none have the experience, miles under their belts, or extensive use of the SN Stack. That’s why chains built using the SN Stack are mainnet-ready from day one.  + +When building a chain using the SN Stack, you get the powerful features that make public Starknet exceptional—unmatched TPS, low L1-settlement and data-availability costs, efficient state diffs, and cutting-edge proving tech—plus the ability to play around with the parameters, such as block times and block sizes. You also enjoy predictable costs and the freedom to brand your own platform. It’s your very own Starknet, with all the customizability you need. + +## Three flavors to best fit your needs + +The SN Stack is the only tech stack in the market allowing appchain builders to choose between three different flavors of stack implementations. You can choose the battle-tested, top-performant **StarkWare Sequencer** flavor and get all the advantages of Starknet for your very own platform. Or you can choose the fully customizable **Madara** flavor, which is a community-based, open-source and appchain-centered project, built from the ground up with appchains in mind. If you are building an onchain game, you should try the **Dojo** flavor, which is optimized for handling the most demanding onchain games, and leverage its extensive toolchain—seamlessly out of the box—including features like Controller, native indexer, Paymaster, and VRF. + +This modular structure allows us to enjoy the best of all worlds. Each flavor brings its own unique strengths, while all share the same heavily battle-tested core Starknet components—Starknet OS, CairoVM, Blockifier, provers and verifiers, L1 core contract, and more, making them all as reliable and secure as Starknet.  + +## Why the SN Stack? + +The SN Stack is superior to all other ZK tech stacks in terms of tooling, performance, and cost-effectiveness due to the contributions of several incredible teams building core components of the stack. For example, the CairoVM in Rust and Cairo Native were built and are maintained by LambdaClass; the Atlantic Prover and the Integrity Verifier are developed by the team at Herodotus; and an implementation of hints in Rust, enabling accessible execution of the Starknet OS, was done by Moonsong Labs, among additional contributions by other amazing teams. + +StarkWare, which invented STARK-proving technology, is by far the most experienced team building production-grade ZK products. The Starknet tech stack has achieved incredible results—public Starknet is capable of achieving +1,000 TPS at less than $0.01 per transaction, making it the fastest cost-effective Rollup in production. Appchains built with the SN Stack can expect similar performance by leveraging the same underlying technology, which includes features like proof aggregation, parallelized execution, block packing, data availability compression, and more. Take note: Achieving industry-leading proving speed with the Stone Prover was only the beginning. You’d better hang tight for the launch of next-gen prover Stwo in 2025, taking proving speeds to the next level and unlocking client-side proving, which will add privacy features to appchains.   + +## STARKs everywhere + +This new offering is an expression of a strong belief in the power of the technology behind Starknet to benefit a wide range of purposes. Propagating Starknet tech and broader usage of STARKs, Cairo, and Stwo will empower the next generation of decentralized apps. We’re building towards the integrity web, and the SN Stack is another big step forward.   + +#### Ready to build your very own custom chain with the SN Stack? + +Learn more about the newly launched SN Stack and the different flavors and RaaS providers offering it. + +Learn more + +--- +Sources: + - https://www.starknet.io/blog/starknet-v0135-blob-compression/ +--- + +## Starknet v0.13.5: Lower Fees With Blob Compression + +Home  /  Blog + +Mar 25, 2025 · 4 min read + +By the time you’re reading this, Starknet will already be on **v0.13.5**—but all the big improvements came in **v0.13.4**. The v0.13.5 upgrade rolled out immediately after v0.13.4, bringing minor adjustments to help the ecosystem gear up for the next big upgrade. So, to keep things simple (and avoid confusion), let’s just call it **v0.13.5**, cool? + +The **v0.13.5** Starknet upgrade is now live on mainnet, significantly improving transaction costs and developer experience (DevX). This upgrade ensures that Starknet remains **cost-efficient, even as demand for Ethereum blobs increases**—by optimizing blob usage through state diff compression. Additionally, this version lays the groundwork for the **future fee market** by introducing a new concept: **L2 gas**. + +Let’s dive into what’s new and why it matters. + +## Shelter from the blobstorm + +With demand for Ethereum blobs steadily rising and costs becoming a growing concern, Starknet is staying ahead of the curve. The v0.13.5 upgrade continues Starknet’s commitment to low fees by significantly improving how data is submitted to Ethereum. By optimizing blob usage, it reduces the impact of rising blob costs and makes transactions more cost-efficient. + +The foundation for this was laid in **v0.13.3**, which introduced **stateless compression**. This allowed blobs to be submitted to L1 in a compressed form, reducing the overall size of data Starknet sends to Ethereum. Now, **v0.13.5 builds on this with stateful compression**, an upgrade that optimizes how storage keys are encoded over time, minimizing redundancy and making state updates far more efficient. + +### How does stateful compression work? + +Rather than treating every transaction’s data independently, **stateful compression** tracks and optimizes how storage keys appear over multiple state updates. This means that instead of repeatedly writing the full storage key in the state diff, Starknet can now reference it using an “alias” (a small integer)—**packing more diffs into each Ethereum blob** **and further driving down L1 costs**. + +With this upgrade, Starknet transactions remain as cost-efficient as possible, even in the face of rising Ethereum data costs, reinforcing Starknet’s position as a cost-efficient scaling solution built to last. + +## Future-proofing Starknet: Introducing L2 gas + +Optimizing blob compression is just one piece of making Starknet more cost-efficient for the long run. The next step? Redesigning how fees are structured altogether. + +This upgrade **lays the foundation for what comes next**. Enter **Layer 2** gas-a new resource model introduced in v0.13.5 that will serve as the backbone of **Starknet’s future fee market, planned for v0.14.0**. This shift will make fees more predictable, scalable, and sustainable, reducing volatility over time and setting the stage for a more efficient fee market. + +### What does each type of gas pay for? + +Until now, Starknet transaction fees were closely tied to Ethereum’s gas mechanics. That’s slowly changing. With L2 gas, **each transaction now specifies three separate gas resources and bids**, each covering different aspects of execution and data availability: + +* **L2 gas** covers all **L2-native resources**. +* **L1 gas** covers **L2→L1 messages** sent by the transaction. +* **L1 data gas (aka blob gas)** covers the cost incurred by the sequencer for **submitting state diffs as blobs on L1**. + +**By separating L2 execution costs from L1 gas**, Starknet is preparing the ground for a more predictable and scalable fee structure. This is a key step toward long-term cost stability and performance improvements. Over time, this will allow Starknet to fine-tune its own fee model-ensuring efficient pricing without being directly impacted by Ethereum’s fluctuating gas costs. + +## Don’t panic: Error handling for a better DevX + +Beyond fee reductions, v0.13.5 also gives developers a major improvement in contract execution: **error handling**. Smart contracts can now catch errors instead of aborting execution immediately. + +Allowing contracts to catch and handle execution failures translates to a more robust developer experience. With this change, developers gain greater control over execution flows and can now write more resilient applications that respond to unexpected conditions instead of just reverting. + +This is part of a broader shift towards making Starknet easier and more intuitive for developers. Alongside error handling, v0.13.5 introduces a new Wallet-Dapp API, streamlining how wallets and applications interact. It removes rigid dependencies on specific versions of Starknet.js, ensuring the ecosystem can rely on an agreed standard, while also leading to easier integrations between dApps and wallets. + +**Thinking about building on Starknet?** Now’s the time. With lower fees, better DevX, and a growing ecosystem, there’s never been a better moment to build on Starknet. + +## Laying the groundwork for what’s next + +While v0.13.5 brings improvements today, it’s also setting the stage for even bigger things ahead. One of the most intriguing additions is **Cairo-native execution**, a performance boost that allows contracts to run as native machine code instead of being interpreted by the Cairo VM. This optimization is undergoing extensive testing and isn’t being activated on mainnet just yet, but it signals the direction Starknet is heading: toward higher throughput, faster execution, and a network that can scale effortlessly. + +And that’s just the beginning. **v0.14.0 is coming**, bringing 2-second blocks, fee market, and even more efficiency improvements. Every upgrade moves Starknet closer to its goal: becoming a blockchain network that’s scalable, cost-efficient, developer-friendly, and built to last. + +**Want to see what’s coming next?** Explore upcoming features, release timelines, and how the network keeps evolving in the Starknet roadmap. + +## Final Thoughts + +With cheaper transactions, an improved execution model, and a clear path toward scalability, Starknet v0.13.5 is setting the stage for the future of blockchain applications. Whether you’re a developer, a builder, or an everyday user, this upgrade ensures that Starknet remains the best place to build and transact affordably. + +**For a deeper dive** into the technical intricacies of this upgrade, check out the Starknet v0.13.4 Pre-release Notes. And yeah, we’re calling it v0.13.5 here-get with the game. + +--- +Sources: + - https://www.starknet.io/blog/starknet-decentralization-a-roadmap-in-broad-strokes/ +--- + +## Starknet’s Decentralization Roadmap in 2025 + +Home  /  Blog + +Feb 26, 2025 · 5 min read + +Blockchain makes it possible for people to control their assets and transact directly with others on a trustless, secure, and censorship-resistant network. That ideal has the potential to transform entire industries, and it can only be achieved on blockchains that are truly decentralized. Blockchains dominated by a single party or conglomerate don’t *really* have an edge over traditional, centralized networks. + +With the goal of bringing blockchain’s promise to everyone, Starknet is on the path to becoming the first fully decentralized Layer 2 (L2) that massively scales Ethereum. The recent launch of the first phase of staking on Starknet was a leap toward greater decentralization. This year, efforts to enhance Starknet’s decentralization will ramp up on top of continued performance optimizations. + +## Decentralized Starknet in 2025 + +Ethereum was the first blockchain to enable general-purpose computing. It earned its reputation for staying true to the first principles of blockchain: decentralization and security. As a Layer on top of—and thus an extension of—Ethereum, Starknet must also be decentralized and secure. + +The terms “decentralization” and “security” are often used interchangeably. While it’s true that decentralization enhances security, we distinguish between the two in this post. That’s because, unlike other L2 rollups, Starknet has had its ironclad security technology—STARK proofs—in place from the beginning. There has never been a state update approved on Starknet that wasn’t validated by a proof. That means it’s virtually impossible for an invalid transaction to be processed on Starknet. This post will zero in specifically on Starknet’s decentralization journey, and the ways in which it will progress in 2025. + +Starknet’s road to decentralization runs on three main lanes: + +* **Staking:** Building economic security on Starknet toward the decentralized operation of its Proof-of-Stake (PoS) consensus mechanism + +* **Operation:** The decentralization of Starknet’s operation + +* **Governance:** The independence of the Starknet Security Council + +Let’s dive into Starknet’s progress in each of these lanes, and what’s coming up. + +#### Breaking speed records with 992 peak TPS + +Build Lightning-Fast, Scalable dApps on Starknet + +Explore Starknet + +##### + +### Staking + +Crucial to the decentralized operation of Starknet is the acquisition of economic security on the network, a process that is already under way. At a high level, here’s what this means: + +Starknet uses Proof-of-Stake (PoS) as its mechanism for preventing Sybil attacks, in which a single entity or group of entities creates multiple validators to gain disproportionate influence over the network. PoS prevents these attacks by requiring validators to stake tokens. This ensures influence over the network is proportional to the economic cost of acquiring and risking tokens, rather than the number of validators created. + +On Layer 1 PoS protocols, staking starts from genesis, and the consensus layer’s security generally improves with its economic value. For rollups, such as Starknet, the story is different. + +Rollups inherit the security of their settlement layer and accrue economic value even if they don’t decentralize their operation. This dynamic provides an advantage to rollups that *are* on the path to decentralizing their protocol, such as Starknet. That’s because it opens the door to accumulating high amounts and a wide distribution of stake before the decentralization of the protocol. This sets decentralized, public Starknet up in a way that prevents the disproportionate influence of a select few on the network, fostering its stability and a wide distribution of validators. + +As such, Starknet is first gathering *economic security* through staking, and only afterward allowing for decentralized operation of the protocol. + +To this end, Starknet staking began as an *application*, decoupled from consensus—Phase 1 of Starknet staking (Staking v1) went live on November 26, 2024, and has been accumulating economic security ever since. To date, more than 170 million in STRK is being staked by 63,000 delegators and 106 validators. + +Stake your STRK → + +Staking v2 will enter mainnet in Q2 of 2025, coupling staking rewards to stakers attesting blocks. Staking v3 will enter mainnet in Q4 of 2025, coupling staking rewards to block validation. Finally, Staking v4 will make validators fully responsible for maintaining and securing the network by producing, attesting, and proving blocks. + +Each stage of staking contributes to building economic security and opens the door to the decentralized operation of the Starknet protocol. + +### Operation + +In addition to economic security, the decentralization of Starknet’s operation requires a fully functional open-source stack with end-to-end functionality. Enter the SN Stack, which has just recently been made available and enables anyone to use the parts that power Starknet. + +The present architecture of public Starknet relies on the open-source Stone prover and a closed-source sequencer, which are complemented by the open-source Madara and Katana sequencers. Throughout 2025, public Starknet will migrate to a newer stack, founded on the next-gen Apollo sequencer and the Stwo prover, both of which will be open-source. Stwo will make proving on Starknet much more efficient. + +The next step toward the decentralized operation of Starknet will be the decentralization of the consensus layer. This means validators will vote on each Starknet block, and only a sufficient quorum of such votes will finalize a new block. Decentralized consensus is planned to go live on mainnet at the end of 2025. Here is the game plan in broad strokes: + +1. Starknet v0.14.0: Launch of the distributed sequencer architecture comprised of an internal network of 3f+1 nodes running consensus and taking turns building and proposing blocks +2. Production release of the next-gen-sequencer for anyone to run +3. Deployment on Testnet(s) +4. Deployment on Mainnet + +We have omitted subtler milestones pertaining to client diversity, which is crucial for a robust network. We’ll just say there are three *additional* full nodes that are presently integrating consensus and block proposal functionality: Juno, Pathfinder, and Madara (which needs only consensus). + +### Governance + +Given a fixed protocol, there are “meta” matters pertaining to protocol changes. Governance of such matters is a difficult problem without any canonical solutions. For L1 networks, “the protocol” is practically defined by the majority of nodes in the network: If most nodes collaboratively modify their clients, the network remains the same while its protocol changes. Hence, L1 networks can have “informal” governance—nothing is set in stone. + +Rollups, on the other hand, have core contracts on their settlement layers. Even if all L2 clients were modified, the core contract itself can only change through action on the settlement layer. Hence, rollup governance requires explicit permissioning for modifying L1 core contracts. + +The Starknet Security Council is a governance mechanism that decentralizes control over core contracts (both on L1 and L2) pertaining to state updates, staking, and STRK minting (which is managed by smart contracts, unlike Ethereum, where rewards are implemented at the client level). + +Moreover, the Security Council’s capacity to perform L1 state updates allows it to bypass consensus in case of censorship of L1/L2 messages. Thus, the Security Council facilitates censorship resistance in addition to its governance functions. + +A Security Council is a first step toward the decentralized governance of a decentralized Starknet. However, the challenge is broader than formal control core contracts. The governance question has social and technical aspects that require much thought. Improving the decentralization of the mechanism is a core goal of decentralized Starknet. + +## Other features + +While big decentralization moves are set to be made on Starknet this year, other features that aren’t decentralization-related, such as additional fee reductions and UX/DevX improvements, will also be launched. + +**v0.13.4:** This version upgrade introduces: + +* **Stateful compression:** Will reduce fees + +* **L2 gas price:** Introduces fixed price, denominated in fri, for a single unit of L2 gas until fee market in v0.14.4; it decouples L2 computation fees from the L1 gas market + +* **Try/catch for function call failures** + +* **Cairo-native (Sierra → LLVM):** Will boost performance, and potentially TPS + +**v0.14.0:** In addition to the distributed sequencer and potentially Stwo integration, this version will introduce: + +* **2-second blocks, mempool, & fee market:** Better UX, DevX + +For a deeper dive into upcoming features, read the Starknet v0.13.4 pre-release notes, with more to come on v0.14.0. + +## Conclusion + +The journey toward decentralized, scalable blockchain is a monumental challenge, but it must be achieved if blockchain is to achieve its full potential. Starknet stands at the forefront of this mission, proving that scalability and decentralization can coexist without compromise. By advancing staking, open-sourcing its stack, and progressing toward decentralized governance, Starknet is not only shaping its own future but also setting a benchmark for what L2s can achieve. + +Stay tuned for updates about Starknet’s decentralization journey on X. + +--- +Sources: + - https://www.starknet.io/blog/cairo-improvements/ +--- + +## DevEx improvements for Cairo developers are here + +Home  /  Blog + +Mar 23, 2025 · < 1 min read + +*This post was originally published on the Cairo website.* + +Cairo has heard your feedback and is actively working on addressing it! Here are some of the most requested features for Scarb and Starknet Foundry that have just been released for Cairo developers. + +## One-line installer + +Setting up Scarb and Starknet Foundry can be a bit tedious: It requires setting up asdf, adding the plugins for Scarb and Starknet Foundry, and installing the latest version. + +Now, all of this is replaced by a single one-liner: + +``` +curl --proto '=https' --tlsv1.2 -sSf https://sh.starkup.sh | sh +``` + +The following will: + +* Install asdf if you still don’t have it installed +* Download the latest version of the tools +* Set the global variables + +And that’s it! + +You should now have all the essential tools you need to start building, compiling, and testing Cairo contracts for Starknet. + +This tool tries to capture as many edge cases as possible, but no software is perfect. If you have any issues or requests, please open a new issue on the GitHub repo. + +## No more Cargo for Cairo + +Recent Scarb and Starknet Foundry users might have noticed that when updating to a new Starknet Foundry version, the complications begin with compiling… Rust? + +This wasn’t intuitive, and many users didn’t quite understand what was going on and why. For the full explanation, read the rest of this post on the Cairo website: + +Read full post → + +--- +Sources: + - https://www.starknet.io/blog/noir-on-starknet/ +--- + +## Verify Noir ZK proofs on Starknet with Garaga SDK + +Home  /  Blog + +Mar 20, 2025 · 2 min read + +Zero-knowledge (ZK) proofs are key to building privacy-preserving applications. Starknet makes verifying these proofs both cheap and seamless, enabling the scalable development of ZK-enabled apps. The goal, therefore, is to constantly expand the umbrella of developers who enjoy access to efficient proof verification on Starknet. + +To that end, StarkWare and the Starknet Foundation now collaborate with Aztec, a leading privacy network, to introduce a new wave of developers to Starknet. Anyone using Noir—the popular ZK language—can now verify Noir proofs on Starknet without needing to write any Cairo code. This is made possible with the Garaga SDK, developed by Feltroid Prime and supported by StarkWare. So whether you are a Noir developer or a Cairo developer, you can now verify efficiently on Starknet. + +## Starknet: A hub for ZK-enabled apps + +Starknet’s native smart-contract language, Cairo, is purpose-built to harness the unparalleled power of STARK proofs. But the Starknet ecosystem continues to ensure developers using other programming languages can also benefit from Starknet’s capabilities, turning Starknet into a hub for ZK-enabled apps. + +Using Garaga, Noir developers can compile their programs to automatically generate a Cairo verifier, deploy it on Starknet, and verify proofs without writing any Cairo code—all while enjoying lower fees and enhanced performance. This makes it possible for Noir developers to build scalable applications ranging from ZK machine learning (ZKML) to Layer 2 (L2) and Layer 3 (L3) appchains, to other ZK-enabled dApps. + +## How Garaga SDK works + +Garaga makes deploying Noir verifiers on Starknet effortless. Here’s how it works: + +* **Noir-program compilation:** When you compile your Noir code using Garaga, it automatically produces a Noir prover, and a Noir verifier contract written in Cairo. +* **Easy deployment**: The generated verifier is ready for immediate deployment on Starknet. This means you don’t need to learn or write Cairo—Garaga handles the heavy lifting. +* **Cost & performance benefits**: By moving proof verification to Starknet, developers can leverage significantly lower transaction fees and faster processing than traditional onchain verification methods. + +## Get started + +Whether you’re an experienced Noir developer or just beginning your journey into ZK proofs, Garaga offers a cost-effective, high-performance platform to bring your ideas to life. + +For more detailed steps, see the Garaga documentation on generating a Starknet smart contract from your Noir program, or start building with Cairo today. + +--- +Sources: + - https://www.starknet.io/blog/start-your-developer-journey-with-starknet-at-ethdenver/ +--- + +## Start Your Developer Journey with Starknet at ETHDenver | Starknet + +Home  /  Blog + +Feb 6, 2025 · 3 min read + +The Starknet ecosystem is all about empowering developers and founders in their journey to turn powerful ideas into real products. To make this happen, Starknet Foundation’s Ecosystem Team puts considerable time and resources into guiding developers from their first interactions with the ecosystem to launching fully-fledged products. + +Starknet’s developer journey is designed to give you support — both structured and non-structured — at every step of the way. If you’re new to Starknet’s Cairo programming language, we’ve got you covered. If you’re an experienced developer looking for funding, we can prepare you for it. And if you’re a founder looking to scale, or at some other stage of your unique journey, we can help. + +Below, we take a look at the key milestones in the Starknet’s developer journey. + +And if you happen to be at ETHDenver, swing by the Starknet Foundation booth where you will meet ecosystem leaders, fellow developers, and potential collaborators! + +## Basecamp: Your first step into Starknet + +Basecamp is your point of entry into the Starknet ecosystem. Designed to help you understand the inner workings of Starknet and what makes it unique, you’ll begin to deepen your expertise and lay the foundations that you’ll need to start building. + +#### How to get started: + +* Attend a main Basecamp session hosted by the Starknet Foundation or participate in a regional Basecamp run by the community. You can also check out past Basecamp session recordings here. + + Check out Starknet’s Basebamp hub. + + The curriculum is designed for all levels — non-technical participants can gain foundational knowledge, while experienced devs can become Cairo power users. +* Use Scaffold Stark to bootstrap any project quickly and explore available development resources. +* Start networking by attending events or organizing a meetup in your city. +* Contribute to cutting-edge open-source projects via Only Dust and participate in the monthly OD Boost. + +Once you’ve completed Basecamp, you’ll have the basic knowledge and connections to start actively building. + +## Hackathons: Bringing ideas to life + +Now, with a firm understanding of Starknet and awareness of the ecosystem’s key players, you can start applying your skills in Starknet hackathons. To bring your ideas to life, you will: + +* Form a team and build a proof of concept (POC). +* Gain exposure to potential users and receive feedback. +* Compete for prizes, grants, and recognition within the ecosystem. + +Starknet hackathons aren’t just about casual coding. You’ll create real value and solve real problems using Starknet technology, as well as take the next step in your developer journey — the Starknet Hacker House. + +## Hacker Houses: From POC to MVP + +If you shine during a hackathon, or demonstrate strong potential in the ecosystem, apply to the Starknet Hacker House and be selected to attend. Starknet’s highly-focused developer residencies are held quarterly around the world, and are designed to help teams move from POC to MVP. + +* Work alongside top builders in a high-intensity environment. +* Accelerate your product development with mentorship and resources. +* Get a concentrated boost equivalent to six months of independent building. + +After participating in a Hacker House, you should be ready for the next stage — applying for a Starknet Seed Grant. + +## Seed Grants: Turning your MVP into a business + +Okay, you’ve refined your idea, built a working prototype, and assembled a solid team. What’s next? Apply for a Starknet Seed Grant to receive up to $25,000 in STRK in non-dilutive funding. You will have to: + +* Ship your MVP and showcase it to the community. +* Gain visibility through Starknet’s ecosystem support. +* Connect with mentors, receive feedback, and get technical assistance. + +With a seed grant, you’re no longer just exploring Starknet and experimenting with its tech stack — you’re building a business. You’re a founder! + +## Your path from Starknet newb to founder + +Again, the Starknet developer journey is structured to help you progress from learning to launching a real product. + +Ready to get started? + +Join Basecamp today — your gateway into the Starknet ecosystem and the first step toward building something great! + +--- +Sources: + - https://www.starknet.io/blog/art-peace-season-3-recap-and-highlights/ +--- + +## Art/Peace Season 3: Recap and highlights | Starknet’s Onchain Art + +Home  /  Blog + +Mar 9, 2025 · 3 min read + +Updated May 26, 2025 + +Art/Peace Season 3, held between February 21 and 25, 2025, was a blast for the Starknet community. Several thousand people came together for four days of pixeling, battling, and collaborating on a shared canvas. + +> Thirteen canvases, thousands of participants, a Web2-like UX, and a 4-day non-stop battle, all in one timelapse. +> +> Your participation in Art/Peace Round 3 broke records with over 2.2M transactions and 11M pixels placed… all for just ~$4K in total gas fees, averaging only $0.0018… pic.twitter.com/iJ8O1iHan2 +> +> — Starknet 🐺🐱 (@Starknet) March 3, 2025 + +The total number of transactions during Art/Peace reached 2.2 million, proving why Starknet is the best layer for building consumer dApps via signless and gasless transactions with no seed phrase management. + +Keep reading to explore what happened during the event and its broader impact on the Starknet community. + +## What is Art/Peace? + +Art/Peace is a collaborative art game where users place pixels on a large shared canvas and collaborated to build art. The game ran over several days and ended with a final board snapshot. The goal is to give users the feeling of collectively building on a highly responsive art canvas they can explore, interact with, and compete on. + +Here are some of the game features participants get to enjoy: + +* **Seamless Web3 onboarding** – Thanks to the Cartridge Controller, users didn’t need to manage seed phrases or pay gas fees. +* **Placing Pixels** – This is the main user interaction. At any time, a user is allowed to place a pixel onto the canvas. +* **Stencils** – Users can take advantage of artwork templates used to help communities collaborate on an art piece. +* **Voting** – Users could vote on their favorite stencils. +* **Automation** – Users could automate the filling of stencils. +* **AI Agents** – Thanks to the Starknet Agent Kit by Kasar Labs, users could prompt an AI agent to place pixels + +Couldn’t take part in Art/Peace? We have good news: another round of Art/Peace is starting soon. Expect exciting mini-campaigns and quests over the course of the next few months! + +## Winners + +#### 1st Place 6000 STRK + +* Starknet Brother + +#### 2nd Place – 4500 STRK + +* Ponziland and Jokers of Neon + +#### 3rd Place – 2500 STRK + +* WolfPack + +#### Shining Artworks – 1250 STRK Each + +* Starknet brothers + +* Stwo hat + +02faf3bb11a1084ce11f0dd22a27b1091a81f354398e992cbc03cbb316a67481 poolcleaner + +#### Extra Winners – 750 STRK Each + +* STRKFarm + +* Starknet Sisters + +01038c85471729c4482a97991bb239993716507381a07d84b5e2117556a0377a + +* Nice Mammoth + +01cea635ebd5fcf9e6f95fe8ff43dd54856d30a45926586753b47899ed36d6cf 01c24bef2fa86cd66631e6336857afe13f12ed847718e66ff3f2d2ae3f894866 + +* Eli and his bird + +03caf40b5ca7b68ff12c280a2aa4d2606b2eb997f4fec3a7a8548a38cb6504f7 quaesitor + +#### Honorable mentions – 100 STRK Each + +1. ``` + 055a3f6f1ae64cdb9cc40899f7c30f68d985651c1fbc4e492a2cb0bea5e2b1a5 weee444 + ``` +2. ``` + 06133ff8b44b57fb4cccb10dfdbfbaacde08c8d69d4616d5b2e0faf2fcf51b31 cramjam + ``` +3. ``` + 0352f27eb30ab37338f2c065784f711a866f20a18a979f314539c8034239b373 sansiim + ``` +4. ``` + 00caffb42456da90939a42311afe35a49c01dac579bc34c5ddfda3534316d942 onenameonelife + ``` +5. ``` + 010b685e795f70a7fb32d473878154e38a2668372dfe5d01d6cbdd9309d1be7f calc 0592ba6b7c8103d2a48509ec73ee3f712da877924dea2da9f8789bf87ecef5a2 alc + ``` +6. ``` + 06133ff8b44b57fb4cccb10dfdbfbaacde08c8d69d4616d5b2e0faf2fcf51b31 cramjam + ``` +7. ``` + 00bf448e40be58becbf69ff3c629ba3ccb3f3578fc22280c2597f9ffc79f355a 24 8 + ``` +8. ``` + 057c54434905c896cc163358a9057f91b5e3e6a4f60b5a4bef3fdd77c2dc91aa fafqt + ``` +9. ``` + 011610d2c6a67a95e87e678678de2ef6c3d0b8b7255b4a31d42f3be80955c372 flippyad + ``` +10. ``` + 0616ade2400f44a6afab2caaa52153d3bdb41c8e956434b7514717fb3f631bd4 onchainguru0719a7f140a815958dd7dec30e0bb77f72a36742edb3e8f19a150b76b70b5bdd haramide + ``` +11. ``` + 018ba1e628dec7f17dd5de819a10fa3dcf2b6bd14cca504a2b8e0f6cdae48aba asmalsosyal05c524fab004dff9ca2340e66e4d4ae7a91a39ca1a100d355cd0186ce0f4c8f9 schwifty + ``` +12. ``` +  014581602af3c625c6906b278dda41f48c6e9dd63ac1087c90580341593db76d stwo + ``` +13. ``` + 028128245a4cc7a7cb7ae5e51f41f41fe2ff5f3dc335c2361b5c5e2cd6effdcb + ``` +14. ``` + 01038c85471729c4482a97991bb239993716507381a07d84b5e2117556a0377a + ``` +15. ``` + 06c72df8eb9a558542d0dd2546c4c8bbeeaff57d6faff577f03e4ed1261c329d mrfax + ``` +16. ``` + 00b4f10f363330a937a50067ca6f79f3a0a076170838c6ae3679c6f4879b2682 mafiader + ``` +17. ``` + 06133ff8b44b57fb4cccb10dfdbfbaacde08c8d69d4616d5b2e0faf2fcf51b31 cramjam + ``` +18. ``` +  057c54434905c896cc163358a9057f91b5e3e6a4f60b5a4bef3fdd77c2dc91aa fafqt + ``` +19. ``` + 07c4289fdb440308d8bfae8ebf9c645599d94f7bae379c97c26ce7fa781ea01f notoutsmth + ``` +20. ``` + 0571bdfee45cb415b151d59909de752849295282bd31b4e83403baad18bc2eff emrebrother + ``` + +--- +Sources: + - https://www.starknet.io/blog/march-2025-roundup/ +--- + +## Starknet’s monthly roundup: March 2025 + +Home  /  Blog + +Apr 3, 2025 · 3 min read + +*The following is* Starknet\_Digger*‘s monthly roundup, first published on the* Starknet research hub*, which provides updates and developments from the Starknet ecosystem.* + +## This month’s highlights + +### Starknet is the most cost-efficient rollup, and it just got even cheaper + +Starknet v0.13.5 is here, providing lower fees for EVERYONE, better DevX, and some optimizations to prepare the ecosystem for Starknet v0.14.0 coming in Q2 2025. + +Before this update, Starknet was already the most cost-efficient Rollup, and this update has widened the gap even further. In terms of average cost per user, here’s how much more expensive each L2 is compared to Starknet (according to L2Beat): + +* Fuel: ~7.1x more expensive +* Linea: ~7.8x more expensive +* INK: ~8.8x more expensive +* Base: ~13.6x more expensive +* OP Mainnet: ~18.4x more expensive +* Arbitrum: ~25x more expensive + +This means Starknet has far more flexibility in the long run to keep gas fees low for users, which will matter a lot if/when blob prices go brrr. + +### Starknet quickly advancing on its decentralization journey + +First point to mention here is that the vote on Staking v2 ended a few days ago, and all parameters have been approved by the community. + +The two key advancements brought by this v2 are: + +* **Validator block attestation:** Starknet will now run in epochs, and validators will need to attest to randomly selected blocks. +* **Commission changes:** Validators can now increase their commission under strict rules. + +During Q2 2025, these parameters will be implemented on Mainnet, and we’ll be halfway toward the final architecture of STRK staking, only 4 months after launching this journey. Speaking of decentralization, here is the full Starknet plan to become fully decentralized. + +### Starknet creating a new bold narrative: Bitcoin and Ethereum together + +10 months ago, StarkWare announced its plan to scale Bitcoin in addition to Ethereum. + +After months of research, BD, and partnerships, the Starknet ecosystem is finally ready to accelerate and introduce a wide range of new Bitcoin use cases over the coming months. Here’s the full plan. + +And here are the main takeaways and what has already launched since that announcement: + +* Bitcoin staking is coming +* Rune and other Bitcoin assets are coming (a dedicated bridge is currently being built) +* StarkWare has built a strategic reserve of BTC & ETH and plans to accumulate more over time +* Bitcoin Lightning Payments are now directly usable from Starknet via the Braavos mobile wallet, allowing users to pay for real-world purchases in STRK at any vendor that accepts Lightning Network payments +* Xverse, one of the leading Bitcoin wallets, is currently integrating Starknet. Its first product, cross-chain swaps between Bitcoin and Starknet, is already live, allowing users to swap BTC from Bitcoin to STRK on Starknet and vice versa. +* A new incentive program specially designed by the Starknet Foundation for BTC is coming +* iBTC is coming to Starknet +* Users can tips on Nostr using STRK +* Everyone can fund a Cashu wallet privately using Starknet + +Believe me, MUCH more is coming. + +***To read the rest of Starknet\_Digger’s report, view it on the Starknet research hub here.*** + +--- +Sources: + - https://www.starknet.io/blog/develop-dapp-starknet-js/ +--- + +## Develop End-to-End Starknet dApps with Starknet.js + +Home  /  Blog + +May 22, 2025 · 6 min read + +Starknet is a powerful Layer 2 scaling solution for Ethereum that enables developers to deploy and interact with **Cairo-based smart contracts**. But how do we build an end-to-end dApp, from **contract deployment** to **frontend interaction**? + +We relied on **Starkli** (Starknet CLI) to deploy contracts, which is a banger. However, with **Starknet.js**, we can **interact with contracts seamlessly from our frontend** without switching tools. In this guide, we will: + +* **Deploy a contract to Starknet** +* **Read from and write a contract using Starknet.js** +* **Integrate with a Next.js frontend** +* **Connect a Starknet crypto wallet (ArgentX or Braavos)** +* **Perform transactions (increase/decrease a counter)** + +By the end, you’ll have **a fully functional Starknet dApp** running with **Starknet.js**. + +The source code of this demo can be accessed here. + +# Getting Started + +## Prerequisites + +To follow this guide, ensure you have: + +* **Node.js** (v18+) +* **Yarn or npm** +* **A Starknet wallet (ArgentX or Braavos)** +* **Basic knowledge of TypeScript & Next.js** +* **Cairo (for smart contracts)** +* **Scarb (Starknet package manager)** + +There is a single command installation too! You can follow this 1 minute video guide. + +## **Step 1: Setting Up a New Project** + +Simply create a new folder where you want your project to be: + +``` +mkdir counter +scarb init +``` + +You should have the option to choose between the Cairo test and Starknet Foundry; I went ahead with the recommended one for this tutorial. + +This should create a src folder with a lib.cairo file, which will be our contract file in Cairo. This tutorial is not focused on learning cairo but for developers who want to learn Starknet.js, hence using a simple counter contract to interact with smart contract is used. + +This is new lib.cairo file in Cairo which has 3 major functions: + +* read the counter value +* increase the counter value with a custom argument provided through frontend +* decrease the counter value + +``` +// Cairo 2.9.2 + +#[starknet::interface] +trait ITestSession { + fn increase_counter(ref self: TContractState, value: u128); + fn decrease_counter(ref self: TContractState, value: u128); + fn get_counter(self: @TContractState) -> u128; +} + +#[starknet::contract] +mod test_session { + use starknet::storage::StoragePointerWriteAccess; + use starknet::storage::StoragePointerReadAccess; + + #[storage] + struct Storage { + count: u128, + } + + #[abi(embed_v0)] + impl TestSession of super::ITestSession { + fn increase_counter(ref self: ContractState, value: u128) { + self.count.write(self.count.read() + value); + } + + fn decrease_counter(ref self: ContractState, value: u128) { + let current = self.count.read(); + if current >= value { + self.count.write(current - value); + } else { + self.count.write(0); // Prevents underflow + } + } + + fn get_counter(self: @ContractState) -> u128 { + self.count.read() + } + } +} +``` + +Once the contract is there, we should build it to get the casm and sierra files. This can be done using these commands. Make sure to be inside the contracts folder. This step might take a while. + +``` +cd contracts +scarb build +``` + +After compiling, your **ABI** (Application Binary Interface) and contract artifacts will be inside target/dev/ including sierra and casm files. + +## **Step 2: Connecting to a Starknet Wallet** + +### Installing a wallet + +Download **ArgentX** or **Braavos**: + +• ArgentX Chrome Extension– standard account + +• Braavos Wallet + +Once installed, **create an account** and **fund it with Sepolia ETH**. + +## **Step 3: Deploying the Contract** + +We will use **Starknet.js** to deploy the contract. + +**For this tutorial, we’d need:** + +1. The contract’s ABI +2. The contract’s Address +3. An Argent or Braavos wallet +4. React.js [front-end framework] +5. Starknetjs [dependency]Make a new file called deploy.ts in the root directory. Since, our contract is already there as we’re using public RPC URL, we’d just be deploying a new instance of it. If you’re using your own new contract, follow these steps to deploy it. + +This is your deploy.ts file which is simply used to deploy your contract. Here we’re only deploying a new instance of it. You’d need a wallet account with the address, private key, and classHash of the contract. To save the ABI, I’ve logged it here and saved it in a separate JSON file inside public folder as you’d need to access it later. + +After your contract is deployed, save its address and check it on Starkscan/voyager. + +``` +import { + Contract, + Account, + json, + shortString, + RpcProvider, + hash, +} from "starknet"; +import fs from "fs"; + +async function main() { + const provider = new RpcProvider({ + nodeUrl: "https://starknet-sepolia.public.blastapi.io", + }); + + // Check that communication with provider is OK + const ci = await provider.getChainId(); + console.log("chain Id =", ci); + + // Initialize existing Argent X testnet accountn + const accountAddress = + "0x..."; + const privateKey = + "0x...."; + const account0 = new Account(provider, accountAddress, privateKey); + console.log("existing_ACCOUNT_ADDRESS =", accountAddress); + console.log("existing account connected.\n"); + + // Since we already have the classhash, we will be skipping this part + const testClassHash = + "0x396823b2b056397dc8f3da80d20ae8f4b0630d33b089b36ba3c3c9a7a51c7d0"; + + const deployResponse = await account0.deployContract({ classHash: testClassHash }); + await provider.waitForTransaction(deployResponse.transaction_hash); + + // Read ABI of Test contract + const { abi: testAbi } = await provider.getClassByHash(testClassHash); + if (testAbi === undefined) { + throw new Error("no abi."); + } + + // ✅ Log Full ABI + console.log("Full ABI:", JSON.stringify(testAbi, null, 2)); + + // Connect the new contract instance: + const myTestContract = new Contract(testAbi, deployResponse.contract_address, provider); + console.log("✅ Test Contract connected at =", myTestContract.address); +} + +// contract address: 0x75410d36a0690670137c3d15c01fcfa2ce094a4d0791dc769ef18c1c423a7f8 + +main() + .then(() => process.exit(0)) + .catch((error) => { + console.error(error); + process.exit(1); + }); +``` + +Use this command to run your deploy file. + +``` +npx tsx deploy.ts +``` + +I’ve attached my ABI.json file here for reference: + +``` +[ + { + "type": "impl", + "name": "TestSession", + "interface_name": "counter_starknetjs::ITestSession" + }, + { + "type": "interface", + "name": "counter_starknetjs::ITestSession", + "items": [ + { + "type": "function", + "name": "increase_counter", + "inputs": [ + { + "name": "value", + "type": "core::integer::u128" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "decrease_counter", + "inputs": [ + { + "name": "value", + "type": "core::integer::u128" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "get_counter", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u128" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "event", + "name": "counter_starknetjs::test_session::Event", + "kind": "enum", + "variants": [] + } + ] +``` + +## Step 4: Connecting contracts to frontend + +Create a new folder and initialize it with the next.js (App router), and install starknet-react, which uses starknet.js under the hood to interact with frontend. + +``` +mkdir web +npx create-next-app@latest starknet-counter +cd starknet-counter +npm install starknet @starknet-react/core @starknet-react/chains +``` + +Move your ABI.json file to the public folder to access it more easily. + +Create a new component called Providers.tsx to configure chains, providers, connectors, wallets, and accounts. This will be a client-side component. + +``` +"use client"; +import React from "react"; + +import { sepolia } from "@starknet-react/chains"; +import { + StarknetConfig, + argent, + braavos, + useInjectedConnectors, + voyager, + jsonRpcProvider +} from "@starknet-react/core"; + +export function Providers({ children }: { children: React.ReactNode }) { + const { connectors } = useInjectedConnectors({ + // Show these connectors if the user has no connector installed. + recommended: [ + argent(), + braavos(), + ], + // Hide recommended connectors if the user has any connector installed. + includeRecommended: "onlyIfNoConnectors", + // Randomize the order of the connectors. + order: "random" + }); + + return ( + ({nodeUrl: process.env.NEXT_PUBLIC_RPC_URL})})} + connectors={connectors} + explorer={voyager} + > + {children} + + ); +} +``` + +Then go to your layout.tsx file and wrap it in the Providers component. Don’t forget to import it. This is how it should look like: + +``` +import type { Metadata } from "next"; +import { Geist, Geist_Mono } from "next/font/google"; +import "./globals.css"; +import { Providers } from "./components/Providers"; + +const geistSans = Geist({ + variable: "--font-geist-sans", + subsets: ["latin"], +}); + +const geistMono = Geist_Mono({ + variable: "--font-geist-mono", + subsets: ["latin"], +}); + +export const metadata: Metadata = { + title: "Counter Starknetjs", + description: "Counter demo by starknet js", +}; + +export default function RootLayout({ + children, +}: Readonly<{ + children: React.ReactNode; +}>) { + return ( + + + + {children} + + + + + ); +} +``` + +We’d need another component to check wallet connection; this will also be a client-side component that will let the users connect or disconnect their Braavos or Argent wallet while also showing their address. This is how my WalletBar.tsx file looks like: + +``` +"use client"; +import { useConnect, useDisconnect, useAccount } from "@starknet-react/core"; + +const WalletBar: React.FC = () => { + const { connect, connectors } = useConnect(); + const { disconnect } = useDisconnect(); + const { address } = useAccount(); + + return ( +
+ {!address ? ( +
+ {connectors.map((connector) => ( + + ))} +
+ ) : ( +
+
+ 🔗 Connected: {address.slice(0, 6)}...{address.slice(-4)} +
+ +
+ )} +
+ ); +}; + +export default WalletBar; +``` + +## Step 4: Reading data from blockchain + +We’d modify our page.tsx file to read the data from blockchain and connect our wallet as well. This will also be loaded on the client side so, add “use client” on the top. + +We will be using pre-defined react hooks for this. + +``` +export default function Home() { + // ✅ Read the latest block + const { data: blockNumberData, isLoading: blockNumberIsLoading, isError: blockNumberIsError } = useBlockNumber({ blockIdentifier: "latest" }); + + // ✅ Read your balance + const { address: userAddress } = useAccount(); + const { isLoading: balanceIsLoading, isError: balanceIsError, error: balanceError, data: balanceData } = useBalance({ address: userAddress, watch: true }); +} +``` + +## Step 5: Interacting with smart contracts + +For this- we will call functions defined in the contract to increase or decrease the counter. + +``` +export default function Home() { + // ✅ Read from a contract + const contractAddress = "0x75410d36a0690670137c3d15c01fcfa2ce094a4d0791dc769ef18c1c423a7f8"; + const { data: readData, isError: readIsError, isLoading: readIsLoading, error: readError } = useReadContract({ + functionName: "get_counter", + args: [], + abi: ABI as Abi, + address: contractAddress, + watch: true, + refetchInterval: 1000, + }); + + // ✅ Increase & Decrease Counter + const [amount, setAmount] = useState(0); + const handleAmountChange = (event: React.ChangeEvent) => { + const value = event.target.value; + setAmount(value === "" ? "" : Number(value)); + }; +``` + +That’s it! + +You can design the UI as preferred. Here’s how a simple UI can look with all the basic functionality required: + +## **Conclusion** + +In this guide, we: + +* **Wrote & deployed a Starknet contract using Starknet.js** +* **Connected a Starknet wallet** +* **Interacted with the contract using Starknet.js** +* **Designed a Next.js frontend** + +This tutorial provides a **solid foundation** for building **full-stack dApps on Starknet**. The **full source code is available on GitHub**. + +## Resources: + +1. Source code on GitHub- https://github.com/reetbatra/starknetjs-counter +2. Official Starknet.js docs- https://starknetjs.com/docs/guides/intro +3. Starknet-react docs- https://www.starknet-react.com/docs/getting-started +4. Counter contract example- https://starknet-by-example.voyager.online/getting-started/basics/counter + +Stay tuned for more such tutorials along the way. See you in the trenches! + +--- +Sources: + - https://www.starknet.io/blog/paymaster-the-secret-to-making-dapps-feel-like-web2/ +--- + +## Paymaster: The Secret to Making dApps Feel Like Web2 | Starknet + +Home  /  Blog + +May 21, 2025 · 4 min read + +Imagine a world where gas fees no longer hinder smooth and frictionless transactions. With **Paymaster**, we’ve brought this vision to life by allowing users to pay their gas fees using **various tokens**, eliminating the need to hold ETH or STRK just to cover transaction costs. + +Whether you hold **stablecoins, major tokens, or other assets**, you can now transact freely, focusing entirely on using the dApp to its full potential without the hassle of gas management. + +In this blog, we’ll explore **Paymaster’s core functionalities**, its benefits, and how you can integrate it into your **Starknet dApp** for a seamless user experience. + +## What is Paymaster? + +**Paymaster** is an innovative solution that enables **gasless transactions** and flexible gas payments. Instead of requiring users to hold ETH or STRK for transaction fees, Paymaster allows dApps to either **sponsor gas fees** or let users pay using **any supported token**. + +### How Does Paymaster Work? + +1. **Sponsor Gas Fees**: The dApp covers the user’s gas costs, creating a frictionless onboarding experience. +2. **Flexible Token Payments**: Users can pay gas fees with any token they hold, not just ETH or STRK. +3. **Meta-Transactions**: Transactions can be executed on behalf of users, making interactions smoother. + +### Benefits of Paymaster: + +* **Frictionless UX** – No need for users to manage gas tokens. +* **Onboarding Simplification** – New users can interact with dApps without holding ETH. +* **Gas Payments in Any Token** – Users can pay gas fees with stablecoins or any supported token. +* **Improved dApp Adoption** – Lower barriers encourage more interaction. + +> **Use Case Example:**Imagine a DeFi platform where users can swap tokens without worrying about ETH for gas fees. Paymaster makes this possible! +> +> or… +> +> POAPs! You can sponsor user’s gas fees to mint NFTs for free! Now, if that is not onboarding your grandma onchain, idk what is + +--- + +## AVNU’s Paymaster on Starknet + +### **Architecture Overview** + +* **User chooses a gas token**: Instead of ETH, users select USDC, USDT, or another supported asset. +* **Signature Approval**: Users sign a transaction without needing ETH. +* **API Calls**: The dApp makes calls to fetch gas prices, generate typed data, and execute transactions. +* **Transaction Execution**: The Paymaster service handles the rest, ensuring smooth blockchain execution. + +Before diving into **AVNU’s Gasless SDK**, let’s first understand why we need **Paymaster** and whether there are alternative solutions. + +### **The Problem with Traditional Gas Fees** + +On Ethereum and Starknet, users must hold **ETH (or STRK)** to pay for transaction fees. This creates several friction points: + +* New users must **acquire ETH/STRK** before using a dApp. +* Managing multiple tokens for **gas and transactions** adds complexity. +* **Due to gas fee requirements, DeFi, gaming, and consumer applications** struggle with adoption + +* ### **Are There Alternative Solutions?** + + There are a few other solutions available: + + + **Meta-transactions** (Users sign messages, relayers execute the transaction, covering gas fees.) + + **Third-party sponsorship services** (Protocols or projects cover gas fees for new users.) + + **Layer 2 scaling** **solutions** reduce fees but still require ETH/STRK. + +Among these, **AVNU’s Paymaster** offers **a flexible** and **developer-friendly** approach, allowing both sponsorship and token-based gas payments. + +## **Gasless vs Gas-Free: Understanding the Difference** + +### **Gas-Free Transactions** + +Gas-Free means **no fees for the user or dApp**—transactions are executed without any cost. This typically requires a sponsor (like a project or protocol) covering all gas fees. + +### **Gasless Transactions** + +Gasless means the **user doesn’t need ETH** for gas but still pays fees using another token. This eliminates the need to manage ETH, making transactions smoother while keeping a decentralized cost structure. + +## **Do You Need an API Key for Paymaster?** + +### **When is an API Key Required?** + +An **API key is required** in the following cases: + +* **Sponsoring transactions** – If a dApp wants to cover the gas fees on behalf of users, it must authenticate via an API key. +* **Using advanced Paymaster features**, such as rewards-based gas sponsorship. +* **Building and executing typed data via the API** – Required for sponsored transactions. + +### **When is an API Key Not Required?** + +An **API key is NOT required** when: + +* The user is **paying gas fees themselves** using supported tokens (e.g., USDC, USDT, etc.). +* Checking **account compatibility** with the gasless service. +* Fetching **gas token prices** for display in the UI. + +--- + +## Implementing AVNU’s Paymaster in Your Starknet dApp + +## **Setting Up a Basic Starknet Project** + +Before jumping into AVNU’s Gasless SDK, let’s first set up a basic Starknet project. This will help you understand how Paymaster integrates into a real-world dApp. + +### **Step 1: Creating a New Starknet Project** + +Start by setting up a new JavaScript/TypeScript project for Starknet development. + +``` +mkdir starknet-gasless-dapp && cd starknet-gasless-dapp +npm init -y # or yarn init -y +``` + +### **Step 2: Installing Required Dependencies** + +``` +yarn add starknet dotenv @avnu/gasless-sdk axios +``` + +### + +### **Step 3: Setting Up a .env File for API Keys** + +Create a `.env` file to securely store your API keys: + +``` +touch .env +``` + +Inside `.env`, add: + +``` +PAYMASTER_API_KEY=your-api-key-here +``` + +### **Step 4: Setting Up a Basic Starknet Account & Contract Call** + +``` +import { Provider, Account, Contract } from "starknet"; +import dotenv from "dotenv"; +dotenv.config(); + +const provider = new Provider({ rpc: "https://starknet.api.avnu.fi" }); +const account = new Account(provider, "YOUR_ACCOUNT_ADDRESS", "YOUR_PRIVATE_KEY"); + +async function callContract() { + const contract = new Contract("CONTRACT_ADDRESS", ABI, account); + const result = await contract.call("functionName", [param1, param2]); + console.log("Result:", result); +} + +callContract(); +``` + +At this point, we have set up a basic Starknet project that interacts with a contract. However, **this setup still requires ETH/STRK for gas fees**—this is where AVNU’s Gasless SDK comes in. + +## **Using the Gasless SDK Without an API Key** + +If the user is paying gas fees in an alternative token, we can proceed without an API key. + +### **Checking Gasless Compatibility** + +``` +import { fetchAccountCompatibility } from '@avnu/gasless-sdk'; + +async function checkCompatibility(accountAddress) { + const compatibility = await fetchAccountCompatibility(accountAddress); + console.log("Gasless Compatible:", compatibility.isCompatible); +} +``` + +### **Fetching Gas Token Prices** + +``` +import { fetchGasTokenPrices } from '@avnu/gasless-sdk'; + +async function getGasPrices() { + const prices = await fetchGasTokenPrices(); + console.log("Gas Token Prices:", prices); +} +``` + +### **Executing a Gasless Transaction (User Pays with a Supported Token)** + +``` +import { executeCalls } from '@avnu/gasless-sdk'; + +async function executeGasless(account, calls) { + const response = await executeCalls(account, calls, { + gasTokenAddress: "USDC", // User pays gas in USDC + maxGasTokenAmount: BigInt(1000000000), + }); + console.log("Transaction Hash:", response.transactionHash); +} +``` + +## **Using the Gasless SDK With an API Key (Sponsored Transactions)** + +If the dApp wants to sponsor gas fees, we need to use an API key. Contact AVNU to get your own API key. + +### **Fetching Gasless Service Status** + +``` +import axios from 'axios'; +import dotenv from 'dotenv'; +dotenv.config(); + +async function checkGaslessStatus() { + const response = await axios.get('https://starknet.api.avnu.fi/paymaster/v1/status'); + console.log("Gasless Service Status:", response.data); +} +``` + +### **Building Typed Data for Sponsored Transactions** + +``` +async function buildTypedData(userAddress, calls) { + const response = await axios.post('https://starknet.api.avnu.fi/paymaster/v1/build-typed-data', { + userAddress, + gasTokenAddress: null, // Sponsored gas + maxGasTokenAmount: null, // Sponsored gas + calls, + }, { + headers: { 'api-key': process.env.PAYMASTER_API_KEY }, + }); + console.log("Typed Data:", response.data); +} +``` + +### **Executing Sponsored Transactions** + +``` +async function executeSponsoredTransaction(userAddress, typedData, signature) { + const response = await axios.post('https://starknet.api.avnu.fi/paymaster/v1/execute', { + userAddress, + typedData, + signature, + }, { + headers: { 'api-key': process.env.PAYMASTER_API_KEY }, + }); + console.log("Sponsored Transaction Hash:", response.data.transactionHash); +} +``` + +--- + +## Additional Resources + +* AVNU Docs +* Argent Wallet & Session Keys + +--- +Sources: + - https://www.starknet.io/blog/on-chain-gaming-starknet-dojo/ +--- + +## The Rise of On-Chain Gaming: Building on Starknet with Dojo Engine | Starknet + +Home  /  Blog + +May 8, 2025 · 6 min read + +Gaming has evolved significantly, from traditional board games to digital experiences, and now, to on-chain games — a completely new paradigm enabled by blockchain technology. As blockchain-based ecosystems flourish, particularly with the scaling solutions offered by layer 2 technologies, developers have begun exploring new business models, financial incentives, and decentralized ownership structures that were previously impossible. + +In this article, we’ll explore the need for on-chain games, their advantages, and how Dojo Engine helps developers build provable, decentralized, and autonomous games faster than ever before. + +## **History of Games: From Board Games to On-Chain Games** + +Games have been integral to human history, from ancient board games like Chess and Go to modern digital experiences like World of Warcraft and Fortnite. However, the underlying structure of games has remained largely centralized — players interact with a game world owned and controlled by a central entity (developers, publishers, or platforms). + +### + +### **The Transition to On-Chain Games** + +On-chain games introduce a revolutionary concept: games where both state and logic exist entirely on a blockchain. This means that: + +* The game’s rules and mechanics are enforced by smart contracts. +* Players have true ownership over in-game assets. +* The game state is public, auditable, and tamper-proof. +* Games can be composable, allowing external developers to build on top of existing game worlds. + +## + +## **Why Do We Need On-Chain Games?** + +While traditional games rely on centralized servers and game economies controlled by publishers, on-chain games offer a radically different approach: + +### **1. Financialization as Part of the Game** + +Unlike traditional games where financialization is often limited to NFTs, on-chain games integrate economic incentives and value transfer at their core. Players can earn, trade, and stake assets in ways that were previously impossible. + +### **2. Trustless Escrow and Arbitration** + +In traditional games, disputes over in-game assets or transactions rely on centralized authorities. On-chain games use the blockchain as an escrow and arbitrator, ensuring fairness and transparency. + +### **3. New, More Efficient Business Models** + +On-chain gaming allows for atomic payouts, decentralized revenue sharing, and permissionless modding. Developers can monetize gameplay through programmable economies rather than relying on ads or in-game purchases. + +### **4. Composability and Modding** + +The best games in history, such as DOTA and Counter-Strike, started as mods of existing games. On-chain games take this further by offering shared state and open APIs, allowing developers to create new game mechanics, spin-off games, and community-driven extensions. + +**Examples:** + +* **DOTA** (originally a Warcraft 3 mod, now a billion-dollar franchise) +* **Counter-Strike** (originally a Half-Life mod, now a leading FPS title) + +--- + +## **New User-Generated Content (UGC) Business Models** + +On-chain games enable headless games, atomic payouts, and games as protocols, ushering in a new era of community-driven game development. + +### **Examples:** + +* **Loot Survivor Clients** (players generate content in a shared game world) +* **DF Client Plugins** (modular expansions built on top of existing games) + +--- + +## **The Strength of On-Chain Games: Security & High Stakes** + +One of the biggest advantages of on-chain gaming is immutability and trustlessness. + +* **Blockchains exist for escrow**—this is their primary function. +* **On-chain games are impossible to cheat** because game logic is enforced at the smart contract level. +* **High-stakes competitive games** (with financial rewards) become possible without fear of exploitation. + +### **Example: Strategy Game with Buy-Ins** + +A highly competitive real-time strategy (RTS) game where players stake assets before a match. Since all transactions and logic are on-chain, cheating is impossible, and winnings are automatically distributed based on game outcomes. + +--- + +## **Types of On-Chain Games** + +### **1. Short Experiences (Rogue-Likes, Daily Challenges)** + +* Low cost, easy to pick up and play +* Baked-in token loops for rewards +* Game Examples: RYO, Loot Survivor, Paved + +### **2. Session-Based Games (With Stakes, RTS, Civilization-Like Games)** + +* Multiplayer & asynchronous mechanics +* Session-based with buy-ins and rewards +* Game Examples: Eternum, Sky Strife, Dark Forest, ZConquer + +### **3. Autonomous Worlds (Self-Evolving, Persistent Game Worlds)** + +* Decentralized and self-governing +* No single entity owns the game +* No fully autonomous world exists yet, but early prototypes are emerging + +## **What is Dojo?** + +Dojo is an open-source, community-driven provable game engine designed to accelerate on-chain game development. Before Dojo, developers had to build their own indexers, contract architectures, and game clients from scratch. + +With Dojo, developers can go from zero to a fully functional game in just a week. + +### **Why Dojo?** + +* Standardizes the development experience (DevX) for on-chain games +* Simplifies on-chain state management via models +* Minimizes boilerplate code +* Provides powerful developer tooling + +--- + +## **How Does Dojo Work?** + +Dojo extends the Cairo compiler, injects macros, and creates a standardized ORM-like state management system. All states are stored in a World contract, and Dojo contracts mutate this state. + +### **Architecture Overview** + +#### **World Contract** + +* Provides the interface for on-chain worlds +* Designed for composability and extensibility +* Registers models that extend storage +* Deploys contracts that extend logic +* Manages access control for data modifications + +--- + +## **What You Need for This Tutorial** + +To follow along, ensure you have: + +* Dojo installed (`dojoup`) +* Sozo, Katana, Torii, and Origami installed +* A basic understanding of Cairo and smart contract development + +### **Dojo Toolchain Overview** + +* **Sozo**: Command-line tool for managing Dojo projects +* **Torii**: Automatic indexer for your models (SQL/Postgres support) +* **Katana**: Local devnet for testing game logic +* **Origami**: Game development library with common patterns +* **BYO Client**: Official clients in Dojo.js, Unity, C, and more + +--- + +## **Building the Game: Red vs. Blue Team** + +### **Game Overview** + +We are developing **Red vs. Blue Team**, a **map control game** where players join either the **Red** or **Blue** team. Players can **paint tiles** on the game map and aim to **maintain control** of the most territory. However, each player is limited to **one action every 60 seconds**, making strategic tile placement critical. + +### **Game Components** + +To implement this game, we need: + +#### **1. Player Registration** + +* Players will be identified using their **wallet address**. +* Upon registration, a player selects a **team (Red or Blue)**. + +#### **2. Tile System** + +* The game board consists of **tiles**, each defined by **x and y keys**. +* Each tile has a **color** (either Red or Blue) to reflect the controlling team. + +### **Game Functions** + +#### **1. Register Player** + +* A new player joins the game by registering with their **wallet address**. +* The player selects a **team (Red or Blue)**. + +#### **2. Paint Tile** + +* A player selects a **tile (x, y)** to paint in their team’s color. +* A cooldown prevents players from painting **more than once every 60 seconds**. +* The team with the most painted tiles maintains control. + +--- + +# **Let’s jump into code!** + +Contracts and client folders are self-explanatory. However, the key is understanding how we need to run each of them and how they are interlinked. + +Please take a look at the source code here. I initialized the project using the Dojo starter kit. + +The client (React+Vite) application can be run using + +``` +npm install +npm run dev +``` + +Then start the Katana local node with the following command: + +``` +katana --disable-fee --allowed-origins "*" +``` + +In another terminal window, navigate again to the contracts directory and build the contracts using Sozo, and apply the migrations to deploy the contracts: + +``` +sozo build +sozo migrate apply +``` + +Start the Torii server, replacing 0x6457e5a40e8d0faf6996d8d0213d6ba2f44760606e110e03e3d239c5f769e87 with the actual world address if different: + +``` +torii --world 0x6457e5a40e8d0faf6996d8d0213d6ba2f44760606e110e03e3d239c5f769e87 --allowed-origins "*" +``` + +## **Models** + +Models define data structures annotated with `#[dojo::model]` for integration into Dojo. + +### **Tile Model (tile.cairo)** + +``` +#[derive(Copy, Drop, Serde)] +#[dojo::model] +struct Tile { + #[key] + x: u16, + #[key] + y: u16, + color: felt252 +} +``` + +* `#[key] x, y`: Primary keys for grid location. +* `color: felt252`: Stores tile color. + +Each tile represents a grid coordinate where players can paint. + +### **Player Model (player.cairo)** + +``` +const TIME_BETWEEN_ACTIONS: u64 = 120; + +#[derive(Copy, Drop, Serde)] +#[dojo::model] +struct Player { + #[key] + address: starknet::ContractAddress, + player: u32, + last_action: u64 +} + +#[generate_trait] +impl PlayerImpl of PlayerTrait { + fn check_can_place(self: Player) { + if starknet::get_block_timestamp() - self.last_action < TIME_BETWEEN_ACTIONS { + panic!("Not enough time has passed"); + } + } +} +``` + +* `TIME_BETWEEN_ACTIONS`: 120-second cooldown to prevent spam. +* `#[key] address`: Primary key for player identity. +* `check_can_place()`: Enforces action cooldown. + +This structure ensures fair play by restricting frequent updates. + +## **Contract Systems** + +Contracts define the logic that enables players to take actions like spawning and painting tiles. + +### **Actions Contract (actions.cairo)** + +``` +// define the interface +#[dojo::interface] +trait IActions { + fn spawn(); + fn paint(x: u16, y: u16, color: felt252); +} + +#[dojo::contract] +mod actions { + use super::{IActions}; + use starknet::{ContractAddress, get_caller_address, get_block_timestamp}; + use boot_camp_paint::models::{tile::{Tile}, player::{Player}}; + + #[abi(embed_v0)] + impl ActionsImpl of IActions { + fn spawn(world: IWorldDispatcher) { + let address = get_caller_address(); + let player = world.uuid(); + let existing_player = get!(world, (player), Player); + assert(existing_player.last_action == 0, "ACTIONS: player already exists"); + let last_action = get_block_timestamp(); + set!(world, Player { address, player, last_action }); + } + + fn paint(world: IWorldDispatcher, x: u16, y: u16, color: felt252) { + let address = get_caller_address(); + let player = get!(world, (address), Player); + assert(player.address == address, "ACTIONS: not player"); + set!(world, Tile { x, y, color }); + } + } +} +``` + +* **IActions Interface:** Defines the available actions: `spawn()` and `paint(x, y, color)`. +* **spawn() Function:** + + Retrieves the caller’s address. + + Generates a unique player ID. + + Ensures the player doesn’t already exist. + + Records the player in the world state. +* **paint() Function:** + + Retrieves the caller’s address. + + Verifies the caller is an existing player. + + Updates the tile color at the specified `(x, y)` coordinates. + +This system ensures that only registered players can modify tiles and prevents duplicate player creation. + +After running these contracts and building them, you should be able to spin up a local katana devnet. + +## **World Write** + +Once you run the contracts on Katana, you should get a console log of the contract address. Save it for later. + +## **Indexing** + +Then you should be able to start a torii server in a new terminal using this command. + +`torii --world 0x6457e5a40e8d0faf6996d8d0213d6ba2f44760606e110e03e3d239c5f769e87 --allowed-origins "*"` + +Based on this, you should see a graphQL link on the terminal that you can access which will automatically generate schema for you. + +Now, the only portion pending is frontend! Take a look at my older tutorial for the same. + +Wola! This is all you need to get started with dojo-engine. + +## Resources + +1. https://book.dojoengine.org/tutorial/dojo-starter +2. https://www.youtube.com/watch?v=xKYqFMibIB0 +3. https://www.youtube.com/watch?v=sj0lJjufby4 + +--- +Sources: + - https://www.starknet.io/blog/cartridge-controller-lets-talk-about-smooth-ux-for-onchain-games/ +--- + +## Cartridge Controller: Smoothest UX for onchain games + +Home  /  Blog + +May 5, 2025 · 3 min read + +The gaming industry is undergoing a massive transformation with the rise of Web3, bringing true ownership, decentralized economies, and seamless player experiences. However, one of the biggest roadblocks to mass adoption is the complexity of blockchain authentication and wallet management. + +Enter **Cartridge Controller**-a groundbreaking solution designed to make Web3 gaming as seamless as traditional gaming, eliminating the need for complex wallet interactions, gas fees, and private key management. + +In this blog, we’ll explore how Cartridge Controller is revolutionizing Web3 gaming. It enables developers to create frictionless player experiences with account abstraction, session keys, and smart authentication. + +Before we talk any further, try Art-Peace, an onchain game on Starknet, and don’t forget to log in via Cartridge to check for yourself how smooth the UX is! + +Did you notice how the crypto wallet never prompts you to sign every transaction repeatedly? And did I mention that the gas fees are also covered? It can’t get any better; it seems like a normal game, right? With no pop-ups? + +## **The Problem: Why Web3 Gaming Needs Better Authentication** + +Web3 games introduce features like play-to-earn mechanics, NFT-based assets, and decentralized ownership. However, these benefits often come at a cost: complex user onboarding and frustrating blockchain interaction. + +### **The Current Challenges in Web3 Gaming** + +* **Wallet Management** – Players must set up wallets like MetaMask or Argent to access a game. +* **Gas Fees & Transaction Signing** – Every in-game action (buying items, minting NFTs) requires a blockchain transaction, which means **manual approval and gas fees**. +* **Seed Phrases & Security Risks** – Traditional wallets require users to secure seed phrases, which are difficult for mainstream gamers to manage. +* **Interrupted Gameplay** – Constant signing and wallet pop-ups disrupt the immersive experience of gaming. + +This is where Cartridge Controller comes in. It simplifies Web3 authentication and transactions, making Web3 games feel as smooth as traditional games. + +## **Introducing Cartridge Controller: Web3 Gaming, Simplified** + +Cartridge Controller is a smart authentication system designed to remove the friction of blockchain interactions in Web3 gaming. + +### **How Does Cartridge Controller Work?** + +Instead of forcing players to sign every transaction manually, Cartridge Controller leverages account abstraction and session keys to enable gasless, passwordless, and seamless authentication. + +### **Key Features of** **Cartridge Controller****:** + +* **Walletless Authentication** – Players can sign in using familiar methods (Google, Discord, etc.) instead of managing wallets. +* **Session Keys** – Allows automatic signing of transactions for pre-approved actions, reducing pop-ups. +* **Gasless Transactions** – Removes players needing to hold ETH for gas fees. +* **Account Recovery** – No need to remember seed phrases; accounts can be linked to traditional authentication methods. +* **Security & Customization** – Developers can set up granular permissions for transaction execution. + +With Cartridge Controller, Web3 games can offer a frictionless experience, keeping players engaged without blockchain complexity. + +--- + +## + +## **How to Integrate Cartridge Controller in Your Web3 Game** + +Enough bragging now; let’s dive into setting up the Cartridge Controller in a Web3 game using React. + +#### **1. Install the Cartridge SDK** + +Start by installing the required dependencies: + +``` +yarn add @cartridge/controller starknet react +``` + +#### **2. Initialize the Cartridge Controller** + +Create a `controller.js` file and initialize the Cartridge Controller. + +``` +import { Controller } from '@cartridge/controller'; + +const controller = new Controller({ + app: 'your-game-id', + network: 'starknet-testnet', // or 'starknet-mainnet' +}); + +export default controller; +``` + +#### **3. Connect a Player’s Account** + +In your React component, add a login button that connects a player’s account. + +``` +import React, { useState } from 'react'; +import controller from './controller'; + +const Login = () => { + const [player, setPlayer] = useState(null); + + const connectPlayer = async () => { + const account = await controller.connect(); + setPlayer(account); + }; + + return ( +
+ + {player &&

Welcome, {player.address}!

} +
+ ); +}; + +export default Login; +``` + +#### **4. Enable Session Keys for Seamless Transactions** + +With session keys, players can automatically sign transactions without manual confirmations. + +``` +const enableSessionKey = async () => { + await controller.authorize({ + actions: ['moveCharacter', 'claimReward'], // Pre-approved actions + duration: 3600, // 1 hour session + }); +}; +``` + +#### **5. Execute an In-Game Transaction Without Pop-Ups** + +``` +const purchaseItem = async () => { + await controller.execute({ + contract: '0xYourGameContract', + method: 'buyItem', + args: [1], // Buy item with ID 1 + }); +}; +``` + +## **Real-World Use Cases: How Web3 Games Can Use Cartridge Controller** + +### **1. NFT-Based Games** + +* Players can mint, trade, and equip NFTs without needing manual transaction approvals. +* Session keys allow automatic weapon/skin upgrades without signing transactions. + +### **2. Play-to-Earn (P2E) Games** + +* Earnings can be claimed without gas fees interrupting the experience. +* Players can stake and withdraw rewards seamlessly. + +### **3. On-Chain Strategy & Card Games** + +* Moves in turn-based strategy games can be auto-signed, keeping gameplay uninterrupted. +* Deck management, trades, and upgrades happen in real-time. + +--- + +## **Resources and further reading:** + +Start by integrating the Cartridge Controller into your Web3 game today! + +* Cartridge Controller Docs +* Getting Started with Cartridge Controller +* React Example Implementation + +--- +Sources: + - https://www.starknet.io/blog/session-keys-on-starknet-unlocking-gasless-secure-transactions/ +--- + +## How Session Keys on Starknet Revolutionize dApp UX with Gasless Transactions + +Home  /  Blog + +Apr 29, 2025 · 3 min read + +## **Introduction** + +As blockchain adoption grows, user experience remains one of the biggest hurdles. Interacting with decentralized applications (dApps) often requires signing multiple transactions, leading to frustrating delays and gas costs. + +Wouldn’t it be great if users could interact with dApps **seamlessly**, without signing every single transaction? + +This is where **Session Keys** come in. They offer a game-changing way to execute multiple transactions securely without requiring constant user approval. In this guide, we’ll explore the concept of Session Keys on Starknet, understand their benefits, and build a hands-on demo. + +## **What Are Session Keys?** + +A **Session Key** is a temporary key that grants limited transaction execution permissions to a dApp **without requiring user signatures for each action**. Instead of prompting for wallet confirmations on every interaction, session keys enable smooth and uninterrupted dApp usage for a specified period or under defined constraints. + +How Do Session Keys Work? + +1. **User Signs Once**: The user grants permission for a specific session key with predefined rules (e.g., limited to certain functions, time duration, or spending caps). +2. **dApp Executes Transactions**: The dApp uses this session key to sign transactions on behalf of the user within the given constraints. +3. **Session Expires**: After the session key expires (or reaches its limits), it can no longer sign transactions, ensuring security. + +### + +### Why are session keys useful? + +✅ **Gasless Transactions** – Users don’t need to pay for gas on every interaction. + +✅ **Seamless UX** – No need to sign each transaction manually. + +✅ **Fine-Grained Permissions** – Limited scope ensures security. + +✅ **Enhanced Gaming & DeFi** – Enables better automation and fluidity in games and trading platforms. + +> **Use Case Example:**Imagine a blockchain game where you need to approve every move or action. With session keys, the game can execute moves automatically within the approved parameters, improving the user experience! + +## **Session Keys on Starknet** + +Starknet leverages **Account Abstraction (AA)** to enhance smart contract wallets, making session keys possible. Starknet’s session keys operate through **smart contract-based authentication**, allowing fine-tuned access control. + +Key Features: + +* **Smart Contract-Based Access Control**: Permissions are embedded in the wallet’s contract. +* **Granular Constraints**: Developers can define specific function calls, time limits, and spending caps. +* **Enhanced Security**: Session keys have a controlled lifespan, preventing abuse. + +The **Argent Wallet** is a popular implementation of session keys on Starknet, offering developers an API to integrate session-based transactions seamlessly. + +## **Building a Session Key Demo on Starknet** + +Now, let’s build a demo that allows users to interact with a smart contract using session keys, similar to this demo + +**Step 1: Setting Up Your Starknet Environment** + +Ensure you have the following installed: + +``` +curl --proto '=https' --tlsv1.2 -sSf https://sh.starkup.sh | sh +``` + +### **Step 2: Deploying a Smart Contract with Session Key Support** + +We’ll write a simple **Counter Contract** where a session key can increment a counter without needing multiple signatures. + +**Counter Contract (Cairo)** + +``` +#[starknet::interface] +trait ITestSession { + fn increase_counter(ref self: TContractState, value: u128); + fn decrease_counter(ref self: TContractState, value: u128); + fn get_counter(self: @TContractState) -> u128; +} + +#[starknet::contract] +mod test_session { + use starknet::storage::StoragePointerWriteAccess; + use starknet::storage::StoragePointerReadAccess; + + #[storage] + struct Storage { + count: u128, + session_keys: Map, // Store session keys + } + + #[abi(embed_v0)] + impl TestSession of super::ITestSession { + fn increase_counter(ref self: ContractState, value: u128) { + assert!(self.session_keys.contains(&get_caller()), "Unauthorized session key"); + self.count.write(self.count.read() + value); + } + + fn decrease_counter(ref self: ContractState, value: u128) { + assert!(self.session_keys.contains(&get_caller()), "Unauthorized session key"); + let current = self.count.read(); + if current >= value { + self.count.write(current - value); + } else { + self.count.write(0); + } + } + + fn get_counter(self: @ContractState) -> u128 { + self.count.read() + } + + fn add_session_key(ref self: ContractState, key: felt252) { + assert!(is_admin(), "Only admin can add session keys"); + self.session_keys.insert(key, true); + } + + fn remove_session_key(ref self: ContractState, key: felt252) { + assert!(is_admin(), "Only admin can remove session keys"); + self.session_keys.remove(key); + } + } +} +``` + +### **Step 3: Generating and Using a Session Key** + +**Generating a Session Key** + +``` +import { starknet } from "starknet"; + +async function createSessionKey(wallet) { + const sessionKey = starknet.generatePrivateKey(); + const sessionPublicKey = starknet.getPublicKey(sessionKey); + + await wallet.addSessionKey(sessionPublicKey); + + console.log("Session Key Created: ", sessionPublicKey); + return sessionKey; +} +``` + +**Using the Session Key** + +``` +async function useSessionKey(sessionKey, contractAddress) { + const provider = new starknet.Provider(); + const contract = new starknet.Contract(contractAddress, provider); + + await contract.increase_counter(10, { from: sessionKey }); + console.log("Counter incremented using session key!"); +} +``` + +**Session Keys on Starknet**, allows users to interact with a smart contract without manually signing every transaction. By introducing **Session Keys**, we improved UX while maintaining security. + +### **What We Achieved:** + +✅ Implemented a **Session Key-enabled Counter Contract** in Cairo 2.9.2. + +✅ Allowed **temporary access** to session keys with controlled permissions. + +✅ Ensured **security** by restricting actions session keys can perform. + +✅ Demonstrated how **session keys** can enhance gasless transactions and smooth dApp interaction. + +## **Final Thoughts and Resources on Session Keys** + +Session keys provide a robust way to improve blockchain usability by reducing friction in user interactions. With **Account Abstraction (AA) and Session Keys**, developers can build **decentralized applications that feel as smooth as Web2 apps** while maintaining blockchain security and decentralization. + +🚀 **Want to try it out?** + +Deploy your session-key-enabled dApp and share your experience! + +Here is the link to the GitHub repository to follow along: https://github.com/reetbatra/session-keys-demo + +Argent’s guide on session keys: https://docs.argent.xyz/aa-use-cases/session-keys + +More on understanding session keys on starknet: https://starkware.co/blog/session-keys-unlocking-better-ux/#session-keys + +--- +Sources: + - https://www.starknet.io/blog/terraforming-web3-building-games-in-a-post-web2-world/ +--- + +## Terraforming Web3: Building Games in a Post-Web2 World | Starknet + +Home  /  Blog + +Feb 12, 2025 · 2 min read + +Over the last few years, the gaming industry has found itself in the middle of a massive shift. With Web3 technologies and platforms rewriting the rules, players are becoming owners, new economic models are emerging, and the very definition of what it means to build and launch a game is undergoing rapid transformation. And with the new plot twist of emerging AI-powered game animation products, now is one of the most interesting moments in gaming history. + +But let’s be real: launching a Web3 game with the global impact and reach of Web2 and AAA games remains a significant challenge. Which is why Starknet is kicking off “Terraforming Web3: Building Games in a Post-Web2 World” — a webinar series designed to help game developers, founders, and builders navigate the post-Web2 world. + +So join Starknet and our webinar partners from March 5th to April 9th as we collectively chart this new path with topics like in-game economies, game launches, go-to-market strategies, and more. + +Register here → + +## What to expect from the “Terraforming Web3” webinar series + +We’re bringing together some of the brightest minds in Web3 and Web2 gaming. Episode-by-episode, we will explore the pillars of this new frontier in gaming, so you can learn, generate new ideas, and start building next-generation gaming entertainment. + +Starting March 5th, tune in for: + +* **Episode 1: From Web2 to Web3** — The state of Web3 gaming, and how Web2 design can blend with Web3 toolkits. +* **Episode 2: Building Web3 Gaming Ecosystems** — Crafting Web3 a gaming marketing strategy, community building, and launch preparation. +* **Episode 3: Tokenomics** – Designing sustainable in-game economies with tokenized experiences that don’t implode. +* **Episode 4: Forging Partnerships** – Forging the right connections that can make or break your game. +* **Episode 5: Learning from Veterans** – Lessons from the builders who’ve been in the trenches and lived to tell their stories. +* **Episode 6: Web3 Gaming & AI Agents** — A dive into AI agents and their fit for on-chain games. + +The “Terraforming Web3” webinar series is more than just another Web3 gaming panel — it’s a roadmap to building, launching, and scaling games that matter. + +## Register now to chart the post-Web2 gaming world + +The first episode kicks off on March 5th. Secure your spot today and start shaping the future of gaming entertainment. Gaming’s new era isn’t going to build itself tomorrow. Let’s terraform it together — today. + +Register here → + +--- +Sources: + - https://www.starknet.io/blog/starknet-foundation-grants-get-up-to-speed-at-ethdenver/ +--- + +## Starknet Foundation Grants: Get up to speed at ETHDenver | Starknet + +Home  /  Blog + +Feb 14, 2025 · 2 min read + +Building something new is never easy, but the Starknet Foundation is here to help founders, entrepreneurs, and developers turn great ideas into MVPs and launch on Mainnet. The journey from concept to real-world impact takes funding, guidance, and technical support — exactly what the Starknet Foundation Grants Program is designed to provide. + +For Starknet at ETHDenver, the focus is on builders. Those exploring Starknet, refining their projects, or scaling proven solutions can tap into grants that support each stage of development. + +Here’s how the program works, what funding is available, and how to learn more at ETHDenver. + +## Developer Journey: From Basecamp to Seed Grant + +Every project follows a path of discovery, iteration, and growth. The Starknet Developer Journey maps out key milestones, ensuring builders have the resources they need at precisely the right time. + +* **Basecamp** — A time to learn Starknet fundamentals, explore Cairo, and connect with fellow developers. +* **Hackathon** — Prototype, test ideas, and refine approaches through hackathons and early-stage support. +* **Hacker House** — Work alongside top builders and accelerate your product development with mentorship and resources. +* **Grants** — Secure funding to develop an MVP, validate ideas, and engage early users, or scale and expand adoption. + +As your project and team moves through these stages, you will need funding, technical mentorship, and a network of peers — resources that Starknet Foundation grants help provide. + +## How Starknet’s Grants Program works + +Starknet Foundation’s Grants Program funds projects that contribute to the ecosystem. Open-source tooling, new applications, and developer infrastructure all qualify for non-dilutive funding designed to accelerate development. + +There are two primary types of grants. + +### Seed Grants + +Designed to foster the growth of early-stage projects, Seed Grants provide up to $25,000 in STRK to support teams building applications within the Starknet ecosystem. Think of these grants as launchpads for developing meaningful and successful applications and products. Ideal candidates include: + +* Early-stage teams with clarity on their project vision. +* Teams that have developed a minimum viable product (MVP) or proof of concept (POC). +* Projects aiming to build new applications that have the potential to drive usage and create positive user experiences for Starknet users. + +For more details, visit the Seed Grants page. + +### Growth Grants + +To accelerate the growth of later-stage projects, Growth Grants offer up to $1 million in non-dilutive funding to support mature teams with a strong market-fit, who are actively expanding the Starknet ecosystem. Ideal candidates include: + +* Later-stage teams that address a specific ecosystem need. +* Teams with a compelling and reliable product that is live, production-grade, and gaining significant usage. +* Projects that unlock significant value for Starknet by building upon existing tools and infrastructure, introducing major new use cases, and demonstrating significant traction through meaningful on-chain usage. + +For more information, visit the Growth Grants page. + +## Discover more at ETHDenver + +Plan on coming to ETHDenver and want to to learn more about Starknet, the Foundation, and its grants programs? Stop by and meet the team! + +Bring your most important questions — we will discuss your project and get you headed in the right direction. + +The best time to start building is now. + +--- +Sources: + - https://www.starknet.io/blog/starknet-partner-support-build-on-the-shoulders-of-giants/ +--- + +## Starknet Partner Support: Build on the Shoulders of Giants + +Home  /  Blog + +Feb 5, 2025 · 2 min read + +Starknet is more than just a blockchain — it’s an entire ecosystem powered by industry giants. + +From OpenZeppelin’s security standards to The Graph’s data indexing, Nethermind’s Cairo expertise, OnlyDust’s open-source contributions, and StarkWare’s tech stack, these partners form a robust support system that you can tap into for your project. Taken together, these partners and many others provide tangible, best-in-class tooling that empowers you to offer invisible crypto, seamless UX to your users. + +Let’s take a closer look at the partner support that developers, founders, and entrepreneurs can expect to get when they build on Starknet. + +## Your Starknet journey is already paved + +When you build on Starknet, you stand on the shoulders of giants. This enables you to move from idea to MVP to Mainnet with considerable resources and tooling to supercharge your vision. + +### StarkWare: The Bedrock + +The cryptographic muscle behind Starknet, StarkWare ensures high scalability at minimal cost. StarkWare’s core technology is the foundation layer enabling your project to excel without any worry about the usual blockchain bottlenecks. + +### OpenZeppelin: Security at scale + +OpenZeppelin is a crypto industry standard for secure smart contracts. The team delivers their Cairo expertise to the Starknet ecosystem with libraries and frameworks that enable you to build safely and securely, so you can focus on what matters — creating an amazing user experience. + +### The Graph: Data at your fingertips + +By enabling seamless on-chain data access, The Graph cuts through all of the complexity so that your front-end can remain simple. + +### Nethermind: Cairo and Starknet masters + +A highly skilled team in the Starknet ecosystem, Nethermind offers deep expertise in low-level performance optimizations. We encourage you to collaborate with them to push the boundaries of what’s technically possible on Cairo and Starknet. + +### OnlyDust: The open-source catalyst + +OnlyDust is a champion in the Starknet ecosystem for community-driven development and tooling. Their open-source contributions keep the ecosystem agile, empowering you to focus on what really matters — rapid iteration and shipping new features. + +## Invisible crypto, seamless UX + +While “invisible crypto” and “seamless UX” might seem like buzzwords — they hold real, tangible meaning in the Starknet ecosystem. + +“Invisible crypto” means your users won’t ever have to wrestle with gas fees, wallet confusion, or opaque transaction processes. By hiding, or abstracting the complexities of blockchain away from the users, you can focus on spurring mainstream adoption and a frictionless on-ramping process. + +## Harness the collective to build your company + +At Starknet, you won’t have to reinvent the wheel because you’re joining an ecosystem that is already battle-tested. This collective repository of developer knowledge fast-tracks your developer journey and product build, giving you more time to polish user experiences. + +This collective intelligence also enables you to iterate rapidly. Ready-made libraries, data indexing solutions, and a proven scaling engine give you everything you need to push out MVPs and beta tests faster than ever. + +## Claim your spot in the Starknet ecosystem + +Secure your place in the Starknet community by joining Hacker Houses, workshops, or online dev forums. + +Start by joining Starknet’s ETHDenver Hacker House here. + +The deadline to apply is February 10th. We hope to see you there! + +--- +Sources: + - https://www.starknet.io/blog/starknet-hacker-house-why-our-mentors-are-your-products-best-friend/ +--- + +## Starknet Hacker House: Our Elite Mentors Are Your Product’s Best Friend + +Home  /  Blog + +Jan 29, 2025 · 3 min read + +The Starknet Hacker House is a great showcase for how focused mentorship can be a potent accelerant for Web3 projects. + +Our mentors are an unrivaled group of ecosystem leaders — experts in multiple fields who have contributed to and shaped Starknet’s development. They include core contributors, successful founders, and active builders — each with a great deal of hands-on experience with Starknet’s tech stack, product launches, fundraising strategies, and more. + +This blog highlights what you can expect from your mentor at the Starknet Hacker House. + +*There is still time to apply to the Starknet Hacker House at ETHDenver, February 21-25 in Denver, Colorado. You can apply here.* + +## Meet some of Starknet’s outstanding mentors + +To set each participating team up for success, we pair them with a dedicated mentor who will focus on their product success and knowledge building. Mentors actively score and monitor the progress of their assigned teams, guiding them in Cairo development, AI integration, product launches, and more. + +This select group of mentors offers well-rounded support across key areas, including technical development and infrastructure, product strategy and market fit, fundraising and business development, as well as AI and blockchain integration. + +### Technical Powerhouses + +A number of our mentors are technical whizzes, who have founded or worked on projects that are now live on Starknet mainnet. A few notable mentors include: + +* **Jules Doumeche** — Core maintainer of StarknetByExample and Cairo contributor, specializing in Starknet smart contract development. +* **Pierre Bertin** — Lead developer of Dojo at Cartridge, bringing deep Starknet development expertise. +* **Aayush Giri** — Developer Relations at Nethermind and former cryptography research engineer, focusing on blockchain infrastructure. +* **Toni Tabak** — CTO of Spaceshard and key contributor to Starknet’s JavaScript ecosystem. +* **David Barreto** — Lead of Starknet’s main educational program, bringing extensive experience in Starknet. + +### Ecosystem & Business Development + +For ecosystem connections, business development opportunities, and on-chain AI guidance, look no further than: + +* **Jason Rodrigues** — Starknet Foundation veteran with extensive Product development and fundraising experience. Having founded a successful company, he has extensive knowledge in product building. +* **Dylan Kugler** —  Starknet Foundation’s Ecosystem Lead, the main point of contact for ecosystem projects as well as the Seed Grant and Growth Grant programs, with expertise in venture capital and fundraising. +* **Jamie Newton** — AI On-Chain Lead at the Starknet Foundation, specializing in the intersection of artificial intelligence and blockchain technology. + +While this is undoubtedly a formidable list of core mentors, it is not exhaustive. We are always adding new mentors to the Starknet Hacker House roster. In fact, we are excited to announce that additional mentors will be joining us from: + +* The Graph ecosystem +* Starkware’s core team +* The Starknet Foundation + +## Refining product and preparing for Demo Day + +Beyond casual advice and encouragement, the Hacker House offers structured mentorship focused on tangible, real outcomes. To that end, each hacker house team receives: + +* Dedicated mentor check-ins to review technical architecture and product decisions. +* Real-time feedback on implementation challenges from experts who’ve solved similar problems. +* Strategic guidance on product positioning and market fit. +* Hands-on support in preparing compelling demos that showcase your project’s value. +* Access to educational resources and documentation from Starknet’s leading instructors. +* Practice sessions and presentation coaching to ensure you shine on Demo Day. + +## How mentors help founders prepare for Mainnet launch + +The Starknet Hacker House is designed to help projects advance regardless of their current stage. Our holistic mentorship approach supports teams in: + +* Refining their existing products with UX optimization guidance from frontend experts. +* Scaling their protocol design with insights from experienced Cairo developers. +* Enhancing their market strategy with advice from successful founders. +* Building effective cross-protocol integrations with The Graph and other ecosystem partners. +* Developing fundraising strategies with guidance from VCs and ecosystem leaders. +* Support in applying to Starknet Foundation grants and other opportunities provided by ecosystem connections. + +## Apply to the Starknet Hacker House + +Think of the Starknet Hacker House as your launchpad to the next phase in your product development journey. Whether you’re refining an existing mainnet product, preparing for a testnet launch, seeking to improve user experience, or looking to raise your funding round, our mentor network brings the expertise you need. Through the Hacker House’s structured mentorship program, you’ll gain strategic insights and connections that are in sync with your own specific and unique stage and set of goals. + +The stage is set, the mentors are ready, and the resources are in place. Now it’s your turn to take advantage of this unique opportunity to take your Starknet project to the next level — whatever that next level might be for you. + +Apply to Starknet’s ETHDenver Hacker House here. + +--- +Sources: + - https://www.starknet.io/blog/starknet-winter-hackathon-winners-and-whats-next/ +--- + +## Starknet Winter Hackathon: Winners and What's Next + +Home  /  Blog + +Feb 3, 2025 · 3 min read + +The Starknet Winter Hackathon was a two-week online hackathon that brought together developers, blockchain enthusiasts, and web3 builders to explore Starknet’s potential and push the boundaries of decentralized applications. It was also a great opportunity for founders, entrepreneurs, and developers to level up their vision along the development journey. + +Let’s take a look at the winners and talk about what comes next. + +## Winter Hackathon: By the Numbers + +* + 820+ participants from 78 countries. + + 213 projects created, with 50% successfully submitted. + + Workshops and office hours to support builders. + +The Winter Hackathon’s two weeks were filled with a ton of hard work, collaboration, and creative innovation. We’ve come to expect this but it was great to see it unfold in real time. + +## What comes next? + +Great question! + +The Starknet Winter Hackathon is one key milestone in the developer journey. The hackathon gave you the opportunity to turn your ideas into reality while fully leveraging the Starknet ecosystem. + +Now that you’ve successfully leveled up, it’s time to embark on the next adventure — Starknet’s ETHDenver Hacker House. The Starknet Hacker House is an accelerator designed to help you refine your project with access to tools, mentorship, and networking opportunities with VCs and future collaborators. + +Don’t wait. Build. + +Apply to Starknet’s ETHDenver Hacker House here. + +## Winter Hackathon winners + +Each of the five hackathon tracks had three winners. + +### AI Track + +In this track, builders were challenged to build any AI Agents dApps on Starknet, from a prediction market to AI-enhanced (or even AI-powered) governance platform and more. + +* **Lumos** – Optimizing liquidity positions for DeFi LPs. +* **TeleSwap** – A Telegram Mini dApp with AI-powered DeFi actions. +* **Arkthemist** – Arbitration as a Service (AaaS) using AI for dispute resolution. + +### Community Track + +In this track builders were challenged to let their creativity flow and build any dApp on Starknet, including infrastructure, artistic expression, or community-driven purposes. + +* **Scarab Sign** – Multiplayer metatransactions for NFT trading. +* **Leftcurve** – A gamified trading agent arena. +* **DevX Magic** – A one-line installer for Starknet. + +### DeFi Track + +We challenged developers to create any DeFi dApp leveraging Starknet’s infrastructure, including payment systems, treasury management, vaults, borrowing, lending, and more. + +* **Overtrade** – A permissionless, public OTC trading platform. +* **Splyce** – AI-managed decentralized ETFs (dETFs). +* **StarkFPI** – Payment solution bridging international travelers with India’s UPI. + +### Gaming Track + +Builders were inspired to unleash their creativity and build games using the Dojo Stack on Starknet. Whether you’re dreaming of a strategic card game, an NFT-powered adventure, or a multiplayer battle arena, Dojo provides the building blocks you need. + +* **Jokers of Neon Mods** – Customizable card game mechanics. +* **Jump Well Chess** – A checkers-inspired multiplayer game. +* **Breakout Dojo** – A classic Atari-Breakout clone. + +### Telegram Track + +Builders were tasked with leveraging both Telegram and Starknet infrastructure to unlock Web3 for over a billion users. From DeFi applications and NFT platforms to social tools and games, we wanted builders to make blockchain interactions as simple as sending a message. + +* **TeleSwap** – AI-powered DeFi actions via Telegram Mini dApp. +* **Sniq** – A Telegram bot providing real-time meme coin insights. +* **Argonaut** – A Starknet-powered Telegram multisig wallet. + +### Special Challenges + +The hackathon also featured sponsored challenges. Check out the winners for the other sponsored bounties here. + Onward to the ETHDenver Hacker House! + +The Starknet Winter Hackathon showcased the developer community’s creativity and skill. And with over 100 projects built, this is clearly just the beginning. + +The next chapter in Starknet developer journey awaits you at the ETHDenver 2025 Hacker House. + +Apply Now. + +--- +Sources: + - https://www.starknet.io/blog/starknet-at-ethdenver-2025-what-would-you-build/ +--- + +## Starknet at ETHDenver 2025: What Would You Build? + +Home  /  Blog + +Jan 28, 2025 · 2 min read + +At Starknet, we’re all about empowering founders on their unique product development journey. We want to inspire and support founders as they reimagine and reinvent the future of the internet and blockchain. + +Starknet is heading to ETHDenver for the 2025 edition of the United States’s premiere gathering of founders, creators, and builders in the Ethereum ecosystem. + +This year, we want to know: “What would you build on Starknet?” + +So, swing by the Starknet booth at ETHDenver’s Main Event from February 27th to March 2nd. We want to hear from you! You’ll be able to meet and connect with some of the brightest minds in Web3 about zk-rollups and Ethereum scalability solutions. + +Here’s everything you need to know (so far). + +## Developer’s Journey: Building with Starknet + +Starknet has always been committed to the founder’s product development journey, from ideation to mainnet launch and beyond. At our ETHDenver booth you can learn about all of the Starknet technology and opportunities that enable you to: + Build Apps — From groundbreaking dApp or an experimental smart contract, Starknet gives founders the tools and infrastructure to move quickly from idea to IRL. + +Build Businesses — Take your project from an idea to a MVP or Mainnet product with the support of our ecosystem. + +## Supporting founders every step of the way + +ETHDenver isn’t just an event — it’s a launchpad for the next wave of web3 innovation. Here’s how Starknet will support you throughout your journey: + +### Basecamp + +Starknet’s Basecamp is a free bootcamp on Cairo and Starknet. Taught live on Zoom, you quickly learn everything you need to know to become a proficient developer in the ecosystem. + +### Hackathons + +Throughout the year, Starknet hosts a number of hackathons — multi-week events during which founders and developers build innovative projects on Starknet. + +### Hacker Houses + +Starknet Hacker Houses are the ultimate environment for builders to brainstorm, code, and execute their ideas. With mentorship and resources on hand, you’ll have everything you need to succeed. The latest edition, Starknet’s ETHDenver Hacker House, takes place from February 21st to the 25th. There is still time to apply! + +You can apply here. + +### Seed Grants + +We’re putting real resources behind great ideas for founders at this stage of the product development journey. Select projects will have the chance to receive seed funding to turn their ideas into MVPs and Mainnet products. + +### Team Support + +The Starknet team will be on-site and ready to help you navigate the entire product development journey. From technical advice to ecosystem insights, we’ll be at ETHDenver to help ensure your product’s success. + +## What would you build on Starknet? + +Starknet at ETHDenver 2025 is more than an event — it’s a call to action. What would you build if you had the tools, support, and community to turn your vision into reality? + +Visit the Starknet booth and show us what you would build! + +Stay tuned for more updates on Starknet at ETHDenver 2025. + +## Starknet side events + +Here are a few side events you should know about that Starknet Foundation is supporting: + +* **Dojo Day with Cartridge (February 26th)** — A gaming-focused day co-sponsored by Starknet Foundation and Cartridge. +* **NoirCon (February 24th)** — Starknet will speak at the Noir language-focused event, with an onboarding activation that will familiarize Noir developers with Starknet. + +See you there! + +--- +Sources: + - https://www.starknet.io/blog/community-building-at-starknets-ethdenver-hacker-house/ +--- + +## Community Building at Starknet’s ETHDenver Hacker House + +Home  /  Blog + +Jan 20, 2025 · 4 min read + +*It takes two flints to make a fire. Apply to the Hacker House: https://www.starknethackerhouse.io/* + +When the web3 community pictures hacker houses, they might think of hacker teams grinding away in isolation on their project, in between conference talks and parties. + +At Starknet, we like to do the hacker house differently. + +While the Starknet Hacker House has, quite rightly, earned a reputation for being a rigorous product development space, we also make certain that each hacker house is a community hub. We do this because we know that for founders and builders to best refine their MVPs, prepare for Mainnet launch, or move from early-stage projects to successful startup, they require something more than a temporary gathering. + +The most successful web3 project founders and developers also need a sustainable community network with lasting connections. + +We want you to see beyond the work, where the best ecosystems also include the strongest community connections. A hub that moves with you along your product development journey, where you can find the community resources to accelerate your product development journey, tap into seasoned mentors and ecosystem experts, find the best collaborators, and get the most fruitful feedback. + +If you feel all of this has been missing from your previous hacker house experiences, then the community building at the Starknet Hacker House is for you. + +## Rethinking community at Starknet Hacker House + +So many people and organizations want to build strong communities. Doubly so in web3. But when it really comes down to it, the results often pale in comparison to the lofty ambitions. + +When we host a Starknet Hacker House, we think a lot about how a community not only takes shape but also how it can be sustained. From the physical space to the official mentors, ecosystem experts, and accepted teams, investors, we incubate communities. Starknet lays the foundations for in-person connections that spark ideas as well as collaborations and breakthroughs that virtual meetings can’t always replicate. + +By the time you leave the Starknet Hacker House, you’ll have more than just a polished project — you’ll have a new and potent community network of allies in the product development journey that lies ahead. + +## Move your project forward on a community journey + +As a team of founders and builders your goal should be to use the time and space of Starknet Hacker House to move your project forward. + +There is no one size fits all approach. + +Maybe you’ve got a strong and promising idea? The Starknet Hacker House community is there to help you develop it. Or perhaps your team is a near-seed candidate on the verge of earning a grant but needing mentorship and other input to finalize your MVP? At Hacker House, you will find a community that can help you get to MVP and beyond. + +Starknet Hacker House communities also see a lot of alumni of other Starknet programs like Basecamp, Buildcamp, hackathons, and even other hacker houses who are still developing their projects. Along their product development journey, they grow their community so they can launch their MVP and ultimately deploy on Mainnet. + +Along the way, you might even meet potential investors or strategic advisors eager to learn more about your idea or product. Wherever you are in your product development journey, there will be new faces and minds to help you. + +## Guidance from Starknet mentors and ecosystem experts + +Mentorship is a key ingredient in transforming your idea into a successful product with real users. At Starknet Hacker House, we pair each team with a dedicated mentor — someone to guide you through tough questions and challenges at the hacker house and beyond. + +Experts from StarkWare, the Starknet Foundation, top global companies like Nethermind and StreamingFast, and other key ecosystem projects will be on hand to answer your most pressing questions. Need fundraising advice? Jason Rodrigues from the Starknet Foundation has your back. Struggling to gauge your progress toward product-market fit? Jamie Newton from the Foundation can help you get clarity. And if you’re tackling technical hurdles with Substreams, a mentor from The Graph is there to assist. + +At Starknet Hacker House, you’ll have access to the people and teams who built the tools and frameworks you’re using. Diana of TapStark captured it perfectly during her Bangkok Hacker House interview: there’s something magical about learning directly from those who’ve been in the trenches themselves. + +## Collaboration and feedback + +Collaboration is at the heart of the Hacker House experience. Bring your product, test it with fellow builders, and get real-time feedback. + +Can people easily use it? Are there pain points or UX issues? These and many more questions will be answered by your Hacker House peers. + +The feedback loop here is instant, honest, and invaluable. Everyone’s rooting for you to succeed, and they’ll go out of their way to help. + +## Building a lasting community + +The Starknet Hacker House is very much about building a community that lasts. Many participants return, not just as builders but as mentors. + +If you were at the Bangkok or Bangalore Hacker House, you might see familiar faces like Mickey from Layer Akira and Carlos de la Figuera, a Starknet Ambassador. + +They’ve been where you are, and now they’re here to share what they’ve learned. Perhaps you’ll even find yourself in a similar position one day. + +## Apply to Starknet ETHDenver Hacker House + +ETHDenver’s Starknet Hacker House is where new ideas can grow, connections can happen, and the future of the ecosystem takes shape. + +It isn’t just a workspace — it’s a community hub where you’ll find inspiration, support, and the tools you’ll need in your own unique product development journey. + +Applications are open. You can apply here. + +--- +Sources: + - https://www.starknet.io/blog/starknet-hacker-house-why-founders-should-apply-to-the-ultimate-launchpad/ +--- + +## Starknet Hacker House: Why Founders Should Apply to the Ultimate Launchpad | Starknet + +Home  /  Blog + +Jan 24, 2025 · 3 min read + +Are you a founder ready to transform your web3 idea project into a tangible product? Starknet Hacker House, a product development hub, is designed for promising projects that are ready to refine their MVPs, prepare for mainnet, and turn early-stage projects into successful startups. + +Starknet’s latest Hacker House will take place during ETHDenver from February 21st to 25th. You can apply here. + +Whether you’re building an MVP, refining your product for real users, or preparing for launch on Mainnet, the ETHDenver Starknet Hacker House will be your best resource in making your idea reality. + +Think of the Starknet Hacker House as a nice, clean alpine lake. Now it’s time for you to dive in and take advantage of all of the resources available to you. + +## Why join the Starknet Hacker House? + +At the Starknet Hacker House, Web3 founders gain access to a number of vital resources for bringing their product to market. + +### A dedicated space for product building + +The Hacker House is a space for founders to make building their priority. You will be surrounded by passionate peers and guided by ecosystem veterans who will be your mentors and collaborators. + +### Real-time feedback + +You will get instant practical input on code, design, and market fit from experienced mentors at the Hacker House. This hands-on guidance enables founders to fast-track product iteration without all of the guesswork that typically comes with Web3 product development. + +### Clear path to Mainnet + +The Hacker House is designed to help teams move from MVP to Mainnet. If you’re ready to grow your idea into a real product, this is the best place to do it. + +### Practical support + +At Starknet’s ETHDenver Hacker House, you will enjoy free lodging, food, and potential travel grants, so you can focus on building. You will also benefit from the Starknet community’s resources, insights, and startup expertise. + +## What sets Starknet Hacker House apart + +The Starknet isn’t like most other Web3 hacker houses, where hackers casually work on projects amidst conference events and parties. It’s hub designed to accelerate product development. + +### Accelerated Product Development + +You don’t just tinker at the Starknet Hacker House — you evolve your project quickly with focused guidance and constant feedback. + +### Deep ecosystem connections + +The relationships and insights you gain at the Hacker House don’t just end. You’ll stay connected with fellow hackers, mentors, and potential collaborators across the vibrant Starknet ecosystem. + +### Real world validation + +Building in isolation can skew founder perception of what users actually need. At the Hacker House, experts challenge your assumptions and help you refine your approach. + +### Built for serious founders + +The Starknet Hacker House isn’t a casual hackathon — it’s a structured program geared toward teams who intend to ship. + +If you’re committed to delivering a working product on Mainnet, you’ll find the resources, networking, and mentorship to make it happen at the ETHDenver Hacker House. + +## What happens after ETHDenver Hacker House? + +Remember, we’ve led you to the picturesque alpine lake. Now it’s on you to dive in. + +* Apply for a seed grant or a growth grant depending on your stage. We can advise you during the hacker house. +* Continue forging connections with the people you met, building a strong network within the Starknet ecosystem. + +We can set the stage and provide the tools, but your project’s success hinges on your own drive to capitalize on every resource and opportunity available. If you’re serious about profitability, you need to make it happen — no one else can do it for you. + +## How to apply + +The road to the Hacker House begins with a single step. + +Apply now. + +--- +Sources: + - https://www.starknet.io/blog/starknet-ethdenver-hacker-house-application-guide/ +--- + +## Starknet ETHDenver Hacker House Application Guide + +Home  /  Blog + +Jan 13, 2025 · 3 min read + +Updated May 27, 2025 + +The Starknet Hacker House, a product development hub, is a unique opportunity for teams and developers with promising projects to take their product development to the next level on Starknet. It’s designed for those ready to refine their MVPs, prepare for Mainnet, or turn early-stage projects into successful startups. The Hacker House will take place in Denver from February 21–25. You can apply here. + +Whether you’re preparing to launch an MVP, refining your product for real users, or taking the final steps toward Mainnet, this Starknet Hacker House application guide is here to help. It’s tailored to support product-focused builders, ensuring you navigate the application process effectively and maximize your chances of being selected. + +## Showcase your skills + +Past web3 and/or Starknet contributions and projects will be key in making your application stand out. A compelling Hacker House application portfolio will include: + +* **Proof of Work** — Showcase your completed projects on platforms like GitHub or personal websites. Highlight any involvement with blockchain, zero-knowledge proofs, or Starknet-specific technologies. +* **Project Progress** — Share details of your current project, emphasizing its development stage. Include information about your MVP, key milestones achieved, and how your work is progressing toward Mainnet or product launch. + Prove your Cairo experience + +Starknet’s native programming language, Cairo, is central to the Starknet ecosystem. Your application should highlight your team’s familiarity with it. + +If you’ve engaged with resources like Only Dust or Starklings, list the completed quests or walkthroughs. These demonstrate your commitment to learning and your ability to navigate the nuances of Cairo. If you’ve developed small-scale projects or experiments in Cairo, share your repositories and briefly describe what you built and any challenges you overcame. + +## Pitch strong, promising ideas + +A solid pitch is a major component of your application. Here’s how to strengthen it: + +* Think about how your project leverages the power of Starknet. +* Consider how your idea can utilize Starknet’s low fees, high speed, account abstraction (for improved user experience), and other unique features. +* Outline the problem you’re solving and its potential impact, using simple, direct language to communicate your vision. +* Highlight what sets your project apart from others in the space, and how your solution fills a gap or creates new possibilities. + +## Build your hacker team + +While the Starknet Hacker House is community-focused, hacker team dynamics should also be a consideration in your application. Consider emphasizing the following: + +* **Complementary Skills** — Highlight your team’s combination of technical, design, and strategic expertise. For example, blending a Cairo developer, a front-end engineer, and a product manager could form a well-balanced and ultimately successful team. +* **Collaborative Experience** — If your team has worked together before, mention past projects or achievements. If this is your first time as a hacker team, explain how your team will be positioned for success at the Hacker House. + +What to expect after submitting your application + +Here’s an overview of the typical application journey, with important dates and information: + +* **Apply** – Submit your application at starknethackerhouse.io. +* **Application Submission Deadline** — Submit your project idea, team details, and proof of work. +* **Selection Criteria** — We’ll select teams and builders based on their technical skills and their ability to continue developing their projects after the event. We’re also looking for projects with strong potential to reach mainnet and grow into successful startups. +* **Applicant Acceptance Email** — Applicants will be notified of their acceptance via email on a rolling basis. +* **Lodging & Food** – Teams will stay free of charge in Denver, be given food throughout the week, and receive the support they need to focus on building their startups. +* **Travel** – Builders can apply for travel grants of up to $500. + +## Other tips for success + +Before submitting, ask peers or mentors to review your application. Constructive feedback can significantly improve your pitch. Reach out to the Starknet Foundation for feedback! You can contact @espejelomar on Telegram—just be sure to allow a couple of days for a response. + +## Who should apply? + +Starknet is targeting early-stage projects, MVPs, and other promising teams who are ready to level up their projects on Starknet. Teams must include at least one Cairo developer (backend/frontend) to ensure they can successfully develop their project, and a non-technical hacker. + +Ideal candidates include: + +* Teams preparing to launch their MVP or nearing Mainnet deployment. +* Teams with a product in development and eager to refine it for real users. +* Teams with a strong, promising idea. +* Seed Grantees — Teams that have already received initial funding and are working toward mainnet. +* Near-Seed Candidates — Teams on the verge of receiving grants and needing mentorship to finalize their MVPs. +* Alumni of Starknet Programs — Graduates of Basecamp, Buildcamp, or previous Hacker Houses (Bangalore, Devcon/Bangkok) who are working to develop their products. +* Hackathon Participants — Builders who excelled in recent events like the Winter Hackathon, 42 School Hackathon, or ETH India and are looking to further develop their projects into an MVP or bring them to Mainnet. + +In short, we are looking for serious, capable builders who are prepared to move from proof-of-concept to a fully functional product. + +## How to apply + +Applications are now open. + +Apply now to the Starknet Hacker House at ETHDenver. + +--- +Sources: + - https://www.starknet.io/blog/starknet-foundation-announces-support-program-for-payment-applications/ +--- + +## Starknet Foundation Launches Support Program for Payment Apps + +Home  /  Blog + +Apr 4, 2025 · < 1 min read + +A vibrant Web3 ecosystem isn’t a byproduct of mere speculation. It’s built on real usage. That’s why Starknet Foundation is supporting initiatives and campaigns launched by Starknet projects designed to accelerate this future. + +Let’s take a closer look at how Starknet Foundation is supporting payments applications with this program. + +Apply for a grant now → + +## How is Starknet Foundation supporting payment applications? + +Under this new grants program the Starknet Foundation will provide monthly STRK grants to eligible builders to help them with their acquisition and to bring their application or new application features to their end users. + +## What a successful payments ecosystem looks like + +Success isn’t doing things the same way they have always been done in crypto. It’s seeing people use Starknet applications in every day settings with the best underlying user experience. + +With this initiative, Starknet Foundation envisions both wallets and fintech apps integrating Starknet payments. We see real economic activity driving on-chain transaction volume instead of only speculative trades. The Starknet Foundation also foresees more strategic partnerships across the payment stack, from stablecoin issuers to payment processors and DeFi rails. + +The ultimate goal is for more people to use crypto the way it was always meant to be used: to power economic growth and develop emerging markets. + +## Get involved + +If you’re a wallet, card provider, or payment protocol ready to build the future of crypto payments, Starknet Foundation wants to hear from you! + +Crypto’s next era won’t be powered by hype but by habits. + +Apply for a grant now → + +--- +Sources: + - https://www.starknet.io/blog/going-beyond-limits-bitcoin-ethereum-and-a-new-foundation-for-the-digital-world/ +--- + +## Going beyond limits: Bitcoin, Ethereum, and Starknet + +Home  /  Blog + +Mar 11, 2025 · 3 min read + +***By James Strudwick, Executive Director, Starknet Foundation.*** + +## A system in need of reinvention + +At Starknet Foundation, our vision is a world where power is shared, creativity is rewarded, and opportunity is accessible to all. As the Starknet L2 moves towards becoming the first protocol to settle on both Bitcoin and Ethereum, I thought it was important to take a moment to talk about this vision, how it has brought us here, and how we see Bitcoin helping us realize it. + +The limits of the current digital world are clear: money, data, and power are concentrated in the hands of the few, limiting opportunity and participation for most, and leaving the internet as a whole a less diverse, creative, and innovative space. It was never meant to be like this. But, as with so many things, we get so used to the way things are that we often stop seeing them. That is, until they break. + +## The rise of digital gold + +The financial crisis of 2008 was exactly this kind of breaking point. We saw with painful clarity the limits of our current financial system, the impossibility of fully trusting financial institutions, and the need to be able to be custodians of our money in a way that was accessible to everyone. Enter Bitcoin. + +With Bitcoin’s launch in 2009 a new, imagined but previously unrealized, horizon opened up. We were presented with a truly global currency that required no intermediaries, no bank account, and no government intervention or regulation. It was a community driven currency open to everyone regardless of wealth, social status, or national origin. + +Unfortunately, as with many young technologies, a combination of technical limitations and bad actors led Bitcoin’s adoption to remain limited early on. Slow transactions, complicated UX, and limited ways to use the token, along with its early reputation for being primarily for illicit activities, proved to be challenging hurdles for Bitcoin. So, while it remained in the popular imagination it did not reach the mainstream or its world changing potential. + +## The birth of the global commons + +Six years after Bitcoin’s initial launch, the second major player in the blockchain space came into being. Unlike Bitcoin, Ethereum wasn’t meant to only be about money, it was intended to be a global commons where people could build everything from currency to identity and governance systems. It was, in a sense, a global computer, but much like Bitcoin, one that was initially held back by its own technological limitations. The UX was equally complicated, and it required learning new conceptual frameworks and programming languages. + +If we fast forward to today, numerous other layer 1 blockchains, as well as layer 2s and layer 3s have arisen, but Bitcoin and Ethereum remain the largest and most important projects in the Web3 space, and in many ways the greatest hopes for bringing this world changing technology to everyone. And this is where Starknet comes in. + +## Web3 at scale + +Although it was originally launched on Ethereum, Starknet wasn’t built only for Ethereum. Starknet was built to be able to scale any chain using STARK proofs in order to create a digital world with integrity thanks to full verifiability. The idea that this would be possible for Bitcoin as well has been there from the very beginning of the project. Now, after countless hours of research and development, we are in a place to begin making this idea a reality. + +That this is now possible, and that Starknet is building the infrastructure and partnerships needed to make this happen is a massive step forward, and a reason to be excited. But what is perhaps even more exciting is what this will enable and what it can mean for the digital world as a whole. + +## A new foundation for the digital world + +By enabling developers to create applications that only need to be built once, using the same code, but that can settle on either Bitcoin or Ethereum, we will enable greater utility for Bitcoin and continue to make Ethereum’s digital commons more accessible to everyone through faster transactions, increased scale, and lower costs. For the first time developers will have true optionality between the leading chains, and can access the strengths of both Ethereum and Bitcoin depending on the application being built. + +Satoshi’s original vision was a digital peer-to-peer payment system that can operate without the need for centralized authority, at scale. Until now, only part of that was possible. By bringing STARK technology to Bitcoin, we are helping to make the full vision a reality. This can bring about a sea change in financial accessibility and inclusion, open up new markets, and create a new foundation for reimagining and reinventing the digital world from the ground up, something that resonates with both Satoshi’s vision as well as our own at Starknet Foundation. + +We are on the precipice of something amazing, and Starknet is leading the way. + +--- +Sources: + - https://www.starknet.io/blog/begin-your-startup-journey-with-founder-basecamp/ +--- + +## Begin your startup journey with Founder Basecamp | Starknet + +Home  /  Blog + +Mar 5, 2025 · 2 min read + +Starting your own business can seem challenging, especially if you’re new to entrepreneurship. You might have a great idea, but figuring out where to start can be overwhelming. Founder Basecamp is here to help you turn those initial thoughts into a real, actionable startup plan. Through four interactive weekly sessions and a final pitch competition, Founder Basecamp will help you shape your idea, craft a compelling pitch, and confidently engage potential customers and investors. + +Whether you’re starting from scratch, have a basic concept, or need guidance shaping your vision, Founder Basecamp is the perfect place to begin your journey. + +Apply now → + +## Why join Founder Basecamp? + +Every successful startup begins with a simple idea. But making that idea clear, convincing, and appealing to customers and investors is tough. Many entrepreneurs stumble due to unclear messaging, poor market validation, or ineffective go-to-market strategies. Founder Basecamp offers you practical support and expert advice to help you transform your initial thoughts into a strong business concept. You’ll learn how to clearly communicate your idea, prove its value to real people, and gain the skills needed to attract funding. + +By participating, you will: + +* Turn your initial idea into a clear and compelling business concept. +* Learn how to validate your idea with real-world insights. +* Build the skills needed to successfully fundraise. +* Gain confidence and clarity to take your startup forward. + +## Who should apply? + +Founder Basecamp is perfect if you: + +* **Are an aspiring entrepreneur** — You’re driven to create something great but need structured guidance to figure out exactly what that could be. +* **Have an existing idea** — You’re clear about what you want to build but need help communicating it effectively to customers and investors. +* **Want to brush up on your entrepreneurial skills** — You’re interested in entrepreneurship and want to sharpen your startup knowledge and pitching abilities. + +## Program Overview + +### Week 1: Idea Refinement & Market Validation + +* Clearly define the problem your startup solves. +* Validate your solution through research and user feedback. +* Set clear, achievable goals to measure your progress. + +### Week 2: Go-To-Market Strategy & Marketing + +* Discover what makes your idea unique and appealing. +* Create a simple plan to attract your first customers. +* Develop clear messaging that excites your target audience. + +### Week 3: Fundraising Fundamentals + +* Understand the fundraising landscape. +* Create an impressive pitch deck to convince investors. +* Practice confidently answering common investor questions. + +### Week 4: Crafting and Perfecting Your Pitch + +* Refine your storytelling techniques to clearly share your startup idea. +* Learn how to use visuals effectively in presentations. +* Practice your pitch with peer feedback for refinement and confidence. + +### Week 5: Pitch Competition + +* Present your idea live to a panel of judges. +* Receive valuable feedback. +* Build confidence for future investor conversations. + +## After the program + +Completing Founder Basecamp isn’t the end! It’s just the beginning. The strongest pitches will earn the opportunity to team up with top technical co-founders from the Starknet ecosystem, entering a product-focused hackathon. This is your chance to rapidly prototype, validate your concept, and lay a solid foundation for your startup’s success. + +## Ready to get started? + +Now is the perfect time to move forward with your startup idea. Founder Basecamp provides the support, community, and practical steps you need to turn your idea into reality. + +Apply now → + +--- +Sources: + - https://www.starknet.io/blog/what-its-like-to-work-at-the-starknet-foundation/ +--- + +## What It’s Like to Work at the Starknet Foundation | Starknet + +Home  /  Blog + +Jan 29, 2025 · 3 min read + +## A different kind of foundation, a different kind of job + +Working at the Starknet Foundation isn’t like any other job. It’s a chance to do something that matters, challenge yourself, leave your mark on an ecosystem that is out to reinvent the digital world, and work with some of the brightest minds in the field. + +With a leadership team with nearly 40 years of collective experience in Web3 ranging from lecturers in blockchain technology, to DeFi experts, to startup founders, to government advisors, to some of the most experienced product people in the field, the Starknet Foundation is a truly unique place to grow a career. + +## Not just another protocol + +Founded by pioneers in cryptography including Eli Ben-Sasson who developed groundbreaking innovations including zk-STARKs and Cairo — the L2 smart contract language — Starknet was launched in 2021 to not only overcome the current technical limitations of Web3, but open new ways to build impactful products that solve real world problems with integrity. This allows founders and developers to think beyond the boundaries of both Web2 and Web3 to bring their most ambitious and creative ideas to life, while making widespread adoption a real possibility through native account abstraction and improved UX. + +Starknet doesn’t simply make Web3 better by making it faster, more efficient, more scalable, and more cost effective, though it does all of those things as well, it fundamentally does something different. Starknet provides a future proof, fully verifiable development platform with its own complete programming language, with the aim of allowing founders and developers unmatched creativity and opportunity. Think of it as a new platform for the digital world, built on verifiability, that can push back against ever growing corporate control and the centralization of power, so we can once again trust the products we use and information we receive. + +Currently the digital world is built to benefit the few by centralizing opportunity and creating a divide between builders and users. Starknet is helping to turn this on its head. Founders get new paths to monetization, distribution, and discovery that build relationships with users and invite them into the life of their projects. Developers get access to a technology stack that unlocks new ways to imagine app development. While users get a range of experiences that aren’t available anywhere else. And all of this is backed by a supportive ecosystem filled with bright and creative minds, funding opportunities, and everything founders and developers need to turn their ideas into sustainable businesses. + +Starknet is the platform for those looking to reinvent everything. From gaming to finance, Starknet’s vision is to build the foundation for a new digital world that increases creativity, opportunity, and participation. + +## Life at the Foundation + +To work at the Foundation is to go beyond the traditional borders of a company. Our impact and reach extends across an entire ecosystem of entrepreneurs and builders, each of whom are at the forefront of their fields, giving everyone who works with us the chance to engage with a broad range of projects that are laying the groundwork for a new digital world. + +We understand that what we are aiming for isn’t small, and that there is no quick path to success, But, by living our values of integrity, long-term thinking, transparency, collaboration, creativity, and purpose in everything we do, we are well positioned to ensure this happens. + +Aligned with our ecosystem entrepreneurs, the culture at the Foundation is dynamic, entrepreneurial, and always evolving. To work here is to know you are making a real difference, having impact, not just on one project or company, but on an entire continually evolving ecosystem. + +Interested in making an impact on an entire ecosystem, and helping to reinvent the digital world? Find your place on the team. + +--- +Sources: + - https://www.starknet.io/blog/history-of-zero-knowledge-proofs/ +--- + +## Zero-Knowledge Proofs History: ZKPs, Blockchain Scalability & Ethereum L2 + +Home  /  Blog + +Share this post: + +Jun 19, 2025 + +Discover the origins and evolution of zero-knowledge proofs (ZKPs) with Eli Ben-Sasson, CEO and co-founder of StarkWare, often hailed as the “Godfather of ZK.” + +In this episode, Eli recounts his pivotal 2013 presentation at a Bitcoin conference near Stanford, where his early research on ZKPs drew the attention of Bitcoin Core developer Greg Maxwell. That moment marked the beginning of over a decade of groundbreaking work focused on harnessing zero-knowledge cryptography to scale blockchain networks while preserving privacy. + +This video explores: + +* The fundamentals and history of **zero-knowledge proofs** +* How ZKPs were adopted for **privacy-first blockchains** like Zcash +* The explosion of **zk-rollups** and **validity proofs** for scaling **Ethereum Layer 2** +* StarkWare’s role in advancing **ZK-based scalability solutions** +* Eli’s renewed focus on applying ZKPs to the **Bitcoin ecosystem** + +Whether you’re new to blockchain or deep into cryptography, this conversation provides essential context on how zero-knowledge proofs became one of the most promising technologies for scaling and securing decentralized systems. + +--- +Sources: + - https://www.starknet.io/blog/dont-stop-hodling-introducing-asset-runes/ +--- + +## Don’t stop HODLing - Introducing Asset Runes | Starknet + +Home  /  Blog + +May 27, 2025 · 2 min read + +### **TL;DR** + +**You can now get native exposure to USDC on Bitcoin, unlocking trust-minimized interaction with the largest and most traded currency.** + +Bitcoiners face a dilemma: the security of Bitcoin vs. the expressibility and composability of other chains. Bitcoiners who sought financial functions such as exposure to other assets were thus forced to explore the broader blockchain sphere, thus compromising in leaving Bitcoin to other, less secure networks to achieve that. + +Enter Asset Runes – a new class of Bitcoin-native assets that are redeemable 1:1 for real-world assets, natively available within Bitcoin, starting with USDC. Explore Asset Runes: + +## **HODL Bitcoin, Use Asset Runes** + +With Asset Runes, HODLers can now diversify their portfolios without leaving the Bitcoin network, starting with USDC and expanding in the future to USDT, ETH, SOL, STRK and many more. Asset Runes are powered by: + +1. Starknet, Ethereum’s leading ZK rollup +2. The Bitcoin<>Starknet Runes Bridge – enabling a secure connection between Bitcoin and Starknet + +## **How it works:** + +In a nutshell, Asset Runes can be bridged to Starknet and then redeemed via smart contracts for the underlying assets in a 1:1 ratio. Let’s give a slightly more detailed overview. + +* Users hold USDC•Starknet directly on Bitcoin. +* USDC•Starknet acts like any other rune, which can be traded trustlessly on Bitcoin mainnet. You can try them out on DotSwap. +* Full reserves: each Asset Rune is backed 1:1 by an actual asset on Starknet. For example, each USDC Rune has a locked counterpart on Starknet. By design, it is impossible for the supply of Asset Runes on Bitcoin to exceed the reserves on Starknet. +* The Bitcoin<>Starknet Runes Bridge, secured by a federation of Bitcoin OGs (you can read all about the validators here), facilitates the secure transfer of funds between the networks. +* Once bridged to Starknet, users can redeem the wrapped Runes for the underlying asset at a 1:1 ratio without any trusted intermediaries. +* In the upcoming weeks, the StarkGate UI will abstract the intermediate wrapper from users, allowing for direct redemption from Bitcoin. Various applications will also integrate with StarkGate, providing the same UX. All are to be announced soon. + +## **More than Asset Runes** + +With ZK tech infrastructure, scale, native account abstraction, and a vibrant ecosystem, Starknet is the ideal candidate for enriching the financial offering for Bitcoiners. + +Asset Runes are an example, with Starknet providing a redemption layer. However, Starknet is also ideally positioned as an arena for asset and value creation: whether you want launchpads or DeFi. + +## **Try Asset Runes Today** + +Open your Xverse wallet, or try them on DotSwap! + +--- +Sources: + - https://www.starknet.io/blog/us-national-bitcoin-reserve-crypto-future/ +--- + +## Can Trump's Executive Order Propel a Crypto Age for the US? + +Home  /  Blog + +Share this post: + +Mar 26, 2025 + +Welcome to the Clear Crypto Podcast, straight talk on what crypto and blockchain do today, and what they’re going to do tomorrow with Nathan Jeffay, Head of Media at StarkWare and Gareth Jenkinson, Managing Editor at Cointelegraph. + +In this episode, we delve into President Trump’s new executive order establishing a U.S. Bitcoin reserve, examining its implications for the crypto industry and the potential for other nations to follow suit. We clarify the key distinction between a Bitcoin reserve and a digital asset stockpile, and bring in crypto attorney Katherine Kirkpatrick Bos to provide legal insights and forecast future regulatory impacts. + +### **Decoding the U.S. Executive Order: A National Bitcoin Reserve** + +The episode kicks off with a deep dive into the recent executive order signed by the U.S. President, a move that has captured the attention of the global crypto community. The order is a significant step, signaling a new, more crypto-friendly era in Washington, especially after a period of regulatory hostility. + +Gareth Jenkinson, the managing editor of Coin Telegraph, explained the two main components of the executive order. Firstly, the order outlines plans for a Bitcoin reserve, with the U.S. government stating its intention to hold onto the Bitcoin it has already seized through law enforcement actions. The government also plans to explore a budget-neutral way to acquire more Bitcoin in the future. This move has been particularly welcomed by Bitcoin advocates, who see it as a validation of Bitcoin’s value proposition as a treasury reserve asset. + +Catherine Cookpatrick provided legal context, explaining that while the executive order is currently in force, it could potentially face legal challenges. If the president is seen as overstepping his constitutional authority, the order could be contested in court, which would pause its implementation. + +### **Bitcoin Reserve vs. Crypto Stockpile: Understanding the Nuances** + +A key point of discussion was the distinction between a “Bitcoin reserve” and a “digital asset stockpile,” a source of confusion for many. Catherine clarified that the executive order actually establishes two separate things. + +* **The Bitcoin Reserve**: This will exclusively hold Bitcoin. The U.S. government intends to hold this Bitcoin as a long-term asset. +* **The Digital Asset Stockpile**: This will consist of other cryptocurrencies that the government has seized. The government will have the ability to strategically liquidate these assets. + +This clarification was seen as a positive development, especially for those who were concerned about other cryptocurrencies being included in a national reserve alongside Bitcoin. Gareth noted that there had been an outcry from the Bitcoin community when the Trump administration previously expressed interest in a broader “crypto reserve” that would include assets like Ether and XRP. The executive order, therefore, provided much-needed clarity on the government’s strategy. + +### **The White House Goes Crypto: A Landmark Summit** + +In addition to the executive order, the episode highlighted the recent White House crypto summit, a highly anticipated event that brought together the titans of the crypto industry. The guest list included a “who’s who” of crypto, such as Michael Saylor of MicroStrategy, Brian Armstrong of Coinbase, and the Winklevoss twins. + +Catherine described the summit as a “fantastic” and “ceremonial” event, a clear indicator of the President’s pro-crypto stance. While she noted that such a large meeting was not the venue for hashing out detailed legislation, the event itself was a hugely positive signal for the industry. It marked a significant shift from the previously hostile regulatory environment. + +### **The Power of Policy: Lobbying and the Future of Crypto in the U.S.** + +The podcast also shed light on the behind-the-scenes forces shaping U.S. crypto policy. Catherine explained that the recent pro-crypto shift is not just due to the President’s personal views, but also the result of the crypto industry becoming a powerful force in Washington. + +She pointed to the influence of Super PACs, particularly the Fair Shake Super PAC, a crypto-focused political action committee that has funneled enormous amounts of money to pro-crypto candidates. This financial backing has helped elect new legislators who are supportive of the industry. + +### **Beyond the Hype: Market Reactions and the Bigger Picture** + +Interestingly, the announcement of the executive order did not lead to a massive spike in the price of Bitcoin, a fact that surprised some market analysts. Gareth explained that the news may have already been priced into the market, as previous announcements from the administration had already influenced Bitcoin’s price rally. + +He suggested that the real impact on price might be seen in the coming months, as other countries may be spurred to acquire more Bitcoin now that the U.S. has clarified its intention to hold the asset. This could trigger a “game theory” scenario among nation-states. + +The hosts and guest emphasized that the podcast would focus on the technology and its implications rather than on price predictions. + +### **Building the Future: The Technology Behind the Headlines** + +The conversation then shifted to the technological advancements in the blockchain space. Catherine expressed her excitement about the future of the technology, which is what drew her away from a career as a big law firm partner. She works at Starkware, the company behind Starknet, which is soon to become the first Layer 2 to settle on both Bitcoin and Ethereum. She highlighted the game-changing potential of blockchain technology and mentioned that Starkware is working on exciting developments related to Bitcoin. + +### **A Day in the Life of a Crypto Lawyer: A Glimpse into Starknet** + +Nathan challenged Catherine to describe her job as a crypto lawyer in simple terms. She explained that her role involves staying on top of regulatory developments, briefing senior management, and analyzing the impact of these developments on the company’s strategy. Ultimately, her goal is to protect the company, manage risks, and enable the builders to continue innovating without interruption. She emphasized the high degree of integrity and talent within the crypto space, a fact she feels is often overshadowed by negative headlines. + +### **What’s Next in Crypto?: Key Trends to Watch** + +Looking ahead, Gareth identified several key trends for listeners to watch. + +* **Cryptocurrency Gains Tax**: He pointed to potential changes in U.S. capital gains tax on crypto, including rumors of a 0% tax, which could be a massive boon for the industry. +* **SEC Enforcement Actions**: The SEC has recently dropped high-profile cases against major crypto companies like Coinbase and ConsenSys, and closed investigations into others, signaling a significant shift in the regulatory climate. Gareth recounted a conversation with Joe Lubin of ConsenSys, who stressed the importance of fighting these legal battles for the future of the industry. +* **The U.S. Bitcoin Reserve**: The development and implementation of the U.S. Bitcoin reserve will be a major story to follow. + +Gareth concluded by remarking on the fast-paced nature of the crypto world, where major news events seem to happen almost weekly, making it one of the most demanding yet exciting fields to cover. + +--- +Sources: + - https://www.starknet.io/blog/what-defines-bitcoins-culture-values-and-future/ +--- + +## What Defines Bitcoin's Culture, Values, and Future? + +Home  /  Blog + +Share this post: + +Apr 3, 2025 + +Welcome to the Clear Crypto Podcast, tune in co-hosts Nathan Jeffay (StarkWare) and Gareth Jenkinson (Cointelegraph) with guest Charlie Spears (Blockspace Media) as they dive into Bitcoin culture, transaction times as a feature, scaling solutions, mining, Tornado Cash ban lift, Tether’s U.S. securities buy, Solana ETF, and more. + +The episode addresses how Bitcoin is more than just money or technology, touching upon topics such as community building within the crypto space, the importance of decentralization, and the evolution and scaling of Bitcoin. Key insights are given into the values held by Bitcoiners and how the vision for Bitcoin can adapt over time. Additionally, notable stories to watch in the crypto world are highlighted, including the strategic adoption of Bitcoin by major companies and the potential impact of stablecoin adoption. + +## **Beyond the Hype: Crypto as a Cultural Movement** + +When you first dip your toes into the world of cryptocurrency, it’s easy to get caught up in the numbers, the technology, and the financial speculation. But as you go deeper, you discover something more profound: a vibrant and diverse culture. Gareth Jenkinson, a seasoned journalist who has navigated countless crypto conferences, describes it as a collection of passionate communities. + +“You can go to a Bitcoin conference, and it’s all Bitcoin. You can go to an Ethereum event, it’s all Ethereum. You can go to a Solana event, it’s all Solana,” Gareth explains. Each of these ecosystems has its own set of believers, its own “tribe.” While this tribalism can sometimes lead to friendly rivalries, it’s a testament to the powerful sense of community that crypto inspires. The hope, as Gareth notes, is that these different groups will increasingly collaborate and support one another as the industry matures. + +These communities are not just confined to conference halls and meetups; they thrive online. In a world where many decry the isolating effects of social media, crypto has fostered incredibly collaborative and creative online spaces. This became especially apparent during the COVID-19 pandemic. While the world was in lockdown, the crypto community was already well-equipped for remote interaction. For many, these online groups provided a vital sense of connection and belonging when physical interaction was impossible. The pandemic era, in fact, saw the rise of many of today’s most prominent crypto influencers and commentators who built their audiences by providing valuable content and fostering online communities when people needed them most. + +## **The Core Values of Bitcoin: More Than Just Code** + +So, what are the foundational ideas that hold these communities together, particularly the Bitcoin community? Charlie Spears, who has spent years reporting on the technical and cultural aspects of Bitcoin, offers a nuanced perspective. “If you ask three different people what the core values are, you’ll get five different answers,” he jokes. However, some common threads emerge. + +At its heart, the Bitcoin culture is built on a set of core values that stem from the **Cypherpunk movement** of the 1990s and early 2000s. This movement was comprised of forward-thinking individuals who believed in using cryptography and mathematics to build a more free and private world. From this foundation, several key principles have become central to the Bitcoin ethos: + +* **Decentralization:** This is perhaps the most fundamental value. As Gareth explains, decentralization means removing the need for a central authority, like a bank or government, to act as the single source of truth. In the Bitcoin network, this is achieved through a vast, distributed network of nodes — computers all over the world running the Bitcoin software. Each node holds a copy of the entire transaction history, the blockchain, and they all work together to validate new transactions. This ensures that no single entity can control the network or alter the records. +* **Building a Permissionless Economy:** The goal is to create a financial system where anyone can participate without needing permission from a gatekeeper. You don’t need to apply for a Bitcoin account; you just need an internet connection. This opens up financial services to people around the world who may be excluded from the traditional banking system. +* **Verifiability and Transparency:** While transactions are pseudonymous, the blockchain itself is completely transparent. Anyone can view the transaction ledger, and anyone can run a node to verify the state of the network for themselves. This creates a system where trust is not required because everything is verifiable. + +Of course, Charlie acknowledges that the crypto world has also seen a significant amount of financialization and speculation. There’s a “Silicon Valley effect” and a playful, sometimes “degen” (degenerate) culture of speculation that coexists with the more idealistic principles. Even the most ardent believers in the technology can’t deny the thrill of the market’s wild swings. + +## **Why Bitcoin’s “Slowness” is a Feature, Not a Bug** + +One of the most common criticisms leveled at Bitcoin is its transaction speed. Compared to a credit card network that can handle tens of thousands of transactions per second, Bitcoin’s network processes only a handful. This leads many newcomers to wonder why a modern technology would be so slow. The answer lies in the principle of decentralization (read more on our decentralization roadmap). + +As Charlie explains, this “slowness” is a deliberate design choice, a feature, not a bug. Think of it like a democracy versus a dictatorship. A dictator can make decisions instantly, but a democracy, with its debates, votes, and checks and balances, moves much more slowly. We accept this slowness because it ensures that power is distributed and decisions are made with the consensus of the people. + +The Bitcoin network operates on a similar principle. To make any changes to the protocol, you need to achieve consensus among a diverse group of participants: + +* **Users:** The individuals and businesses who use Bitcoin for transactions. +* **Miners:** The companies that run the powerful data centers that secure the network and process transactions. +* **Developers:** The global, distributed group of coders who maintain and propose improvements to the Bitcoin software (go to our Developers Hub). + +Getting all of these different parties to agree on changes is a difficult and time-consuming process. This makes the network incredibly resistant to censorship and unauthorized changes. “It’s simple,” Charlie says. “You might call it the comparatively most dumb blockchain, but it’s very, very good at doing the things that it’s doing. It has done this for 16 years, and I think it’ll do it for another 16, 50, a hundred years more.” + +This deliberate pace ensures the network’s security and stability, making it a reliable foundation upon which to build. + +  + +## **Scaling Bitcoin for the Future: A Return to the Original Vision?** + +While Bitcoin’s base layer is designed for security and decentralization, its limited capacity means it can’t serve the daily needs of everyone in the world. This is where the concept of **scaling** comes in. + +Charlie is quick to differentiate scaling from simply making something faster. “When I think of scaling Bitcoin,” he says, “I think of increasing the number of people who can actually access Bitcoin directly… empowering more individuals to access Bitcoin directly without having to go through an intermediary.” + +This leads to the development of **Layer 2** solutions. These are protocols built on top of the Bitcoin blockchain that can handle a much higher volume of transactions quickly and cheaply. Think of the Bitcoin blockchain as the ultimate court of settlement, and Layer 2 solutions as the local courts that handle everyday disputes. This approach allows for massive scaling without compromising the security and decentralization of the base layer. A **crypto bridge** can be used to move assets between Bitcoin’s main layer and these faster, more scalable Layer 2 networks. + +Is this vision of scaling a departure from Bitcoin’s original purpose? Gareth argues that it’s a natural evolution. He points to early writings from figures like Hal Finney, one of the first Bitcoin users, who envisioned a future where Bitcoin would serve as the world’s base settlement layer, a kind of global central bank. + +Adam Back, the inventor of the hashing algorithm that Bitcoin uses, often talks about Bitcoin being both **digital gold and electronic money**. + +* **Digital Gold:** Because of its fixed supply and the difficulty of mining new coins, Bitcoin serves as an excellent store of value, much like physical gold. It’s a hedge against inflation and economic instability. +* **Electronic Money:** Because it is digital, it is far more portable and easier to transact with than physical gold. + +The current push for scaling solutions is an attempt to fully realize this dual nature. The base layer remains the secure “digital gold,” while Layer 2 solutions enable it to function as “electronic money” for everyday transactions, like buying a cup of coffee. + +Charlie adds another fascinating layer to this discussion. He compares interpreting Satoshi Nakamoto’s original writings to interpreting historical texts like the writings of the US founding fathers. “We have things that they said many years ago and we’re trying to see what that should look like today. And there’s a lot that is actually open and unclear.” + +Interestingly, some of the proposed upgrades to the Bitcoin protocol are not new ideas at all. They are features that were included in the original Bitcoin software but were later removed as a precautionary measure. Now, with over a decade and a half of the network running successfully, developers are feeling more comfortable reintroducing these features to expand Bitcoin’s capabilities. + +Ultimately, Charlie leaves us with an empowering message: “Bitcoin is in the hands of you, and you get to decide what Bitcoin should be just as much as someone did 15, 16 years ago.”  + +## **Crypto Stories to Watch** + +As we look to the future, Gareth and Charlie highlight two major stories that everyone in the crypto space should be monitoring. + +### **1. Corporate Bitcoin Adoption** + +Gareth points to the aggressive Bitcoin acquisition strategies of two major companies: MicroStrategy in the United States and Metaplanet in Japan. Both companies have made it their corporate strategy to convert their fiat currency reserves into Bitcoin, believing in its long-term value appreciation. They are even taking on debt to buy more Bitcoin. + +This is a bold and controversial move. Critics worry about the risks involved, particularly if the price of Bitcoin were to experience a significant downturn. However, proponents see it as a sign of growing institutional conviction in Bitcoin as a legitimate treasury reserve asset. As more companies and even nation-states begin to understand the properties of Bitcoin, we could see a significant increase in demand and, consequently, its value. + +### **2. The Rise of Stablecoins** + +Charlie’s story to watch is the adoption of **stablecoins**. These are cryptocurrencies pegged to the value of a fiat currency, such as the US dollar. Stablecoins offer a way to transact on the blockchain with the stability of a traditional currency. + +This has massive implications for the global financial system. For the United States, the widespread use of dollar-pegged stablecoins could extend the reach and influence of the US dollar. Charlie points to Tether, the company behind the largest stablecoin, as one of the most profitable companies in the world, demonstrating the immense potential of this market. + +While Charlie admits that using crypto as rails for the US dollar wasn’t what initially excited him about the space, the pragmatist in him sees the undeniable momentum behind this trend. The growth of stablecoins is set to be a major, and likely controversial, storyline in the coming years. + +As we’ve seen, this is a world of passionate communities, powerful ideas, and constant innovation. Tune in next time as we explore the specific technologies being developed to scale Bitcoin. In the meantime, stay curious and stay safe. + +--- +Sources: + - https://www.starknet.io/blog/how-bitcoins-three-pillars-are-about-to-fix-money/ +--- + +## Can You Ever Buy Coffee With Bitcoin? The Future of BTC Scaling + +Home  /  Blog + +Share this post: + +Apr 10, 2025 + +Join the Clear Crypto Podcast with co-hosts Nathan Jeffay, Head of Media at StarkWare, and Gareth Jenkinson, Head of Multimedia at Cointelegraph, as they welcome Eli Ben-Sasson, StarkWare CEO. + +Explore Bitcoin scaling solutions and dive into Bitcoin’s three groundbreaking principles—decentralization, incentivized integrity, and public verifiability – while discussing how Bitcoin’s design could transform the future of money. + +## **A Vision for Bitcoin’s Future** + +The episode kicks off by putting Eli Ben-Sasson in a hypothetical time machine and asking him what Bitcoin will look like in five years. + +His answer is bold and clear. “The use of Bitcoin in five years will be that, first of all, it is in much more use,” Eli predicts. He envisions a world where the “velocity of Bitcoin”—the number of times a single coin is used in transactions—vastly increases. This won’t be a niche activity for a select few; it will be a “beautiful, blooming economy” built on the same principles of security and decentralization that its anonymous creator, Satoshi Nakamoto, first laid out. + +This vision sets the stage for the episode’s central theme: moving Bitcoin from a passive asset to an active, global financial infrastructure. + +## **From the Ivory Tower to the Blockchain Frontier** + +So, who is the person making these bold predictions? Eli Ben-Sasson isn’t your typical tech CEO. He spent years as a university professor, deep in the world of academic research. What brought him from writing highly specialized papers to running a major blockchain infrastructure company? + +“It’s the same feeling that brought me to academia,” Eli explains. “Love, inspiration, and values.” + +He fell in love with Bitcoin in 2013, captivated by its “vibes, the ideology, the promise, the vision.” This journey from theory to practice underscores a recurring theme in the podcast: crypto is more than technology or an investment; it’s a culture driven by a powerful set of ideas about how society can function. + +## **The Scaling Problem: Blockchain’s Built-In Speed Bump** + +To understand Eli’s work, we first need to understand one of blockchain’s biggest challenges: **scaling**. As discussed in previous episodes, blockchains like Bitcoin and Ethereum are intentionally slow. This slowness is a feature, not a bug, designed to ensure maximum security and decentralization. However, it also creates a bottleneck, limiting the number of transactions the network can process and making fees expensive during high demand. + +This is where Eli and Starknet come in. Their section of the crypto “orchestra” is dedicated to scaling. By building on top of the main blockchain, **Layer 2** solutions like Starknet allow for a massive number of transactions to be processed quickly and cheaply without sacrificing the security of the underlying network. + +Starknet has already worked its scaling magic on Ethereum, and now, it’s turning its attention to Bitcoin. Why? Because, as Eli points out, Bitcoin in its current state struggles to fulfill Satoshi’s original mission. + +“If you go back to Satoshi’s words in the famous white paper, he talks about the need for any two interested parties to interact and transact in a way that is completely trustless,” Eli says. “The sad reality is that today, this is not the case on Bitcoin.” + +## **“In Math We Trust”: The STARKs Approach to Scaling** + +To scale Bitcoin, especially a network so fiercely protective of its integrity, the method matters. Eli’s approach is rooted in a technology he co-invented: **ZK-STARKs**, or Zero-Knowledge Scalable Transparent Arguments of Knowledge. + +It’s a complex name for a beautifully simple concept: a cryptographic proof that is so mathematically sound that it is completely trustworthy. Anything verified with a STARK proof is guaranteed to be correct. + +“Bitcoin’s motto is ‘In Math We Trust’,” Eli notes. “All of the technology that I co-invented… has always been backed by the integrity of math to the point that even if we wanted to violate integrity, the math… would prevent us.” + +This is how Starknet scales Ethereum today and how it plans to scale Bitcoin tomorrow—with a method that honors the core values of the chain itself. + +## **A Meeting of Minds: Vitalik Buterin on Bitcoin’s Evolution** + +The announcement of Starknet’s plan for Bitcoin was marked by a fascinating conversation between Eli and Ethereum’s co-founder, Vitalik Buterin. One might expect a sense of rivalry, but the dialogue revealed a shared respect and a common goal. + +Vitalik, whose own journey began at *Bitcoin Magazine*, expressed his support for the initiative. “Realistically, you know, Bitcoin and [Ethereum] are probably the two most sturdy and stable systems to actually run this kind of thing on top of,” Vitalik commented. “If it succeeds here, then we’ll see how that goes from there.” + +This cross-chain collaboration challenges the narrative of crypto tribalism. As podcast co-host Gareth puts it, “The brightest minds in the space are starting to realize that, hey, we need to help scale Bitcoin… because that is gonna unlock the true value of that chain.” + +## **The Great Debate: To Change Bitcoin or Not?** + +While some scaling can happen now, unlocking Bitcoin’s full potential may require a small tweak to its core code. This idea has sparked a passionate debate within the Bitcoin community. + +* **The Traditionalists:** This group argues that Bitcoin’s code should remain unchanged. Its value lies in its predictability and stability, and any alteration risks compromising that. +* **The Evolutionaries:** This group, which includes Eli, believes that a small, carefully considered change is necessary for Bitcoin to fulfill its destiny. + +Eli’s argument is direct: “We are failing to meet the standard that Satoshi laid out.” He compares Bitcoin today to a Rolex—beautifully engineered, incredibly valuable, but not something you use for everyday activities. “It is something that only the very rich can own in a self-custodial way as intended, and the rest of us can only access it through third parties.” + +By not evolving, Bitcoin risks becoming a pet rock for the wealthy instead of the peer-to-peer electronic cash system for the world it was meant to be. He argues that increasing its utility will bring in more users, generate more fees to secure the network, and ultimately drive its value to “even higher heights.” + +The most astonishing part? The proposed change is tiny. “It’s nine lines of code,” Eli reveals. Nine lines of code to potentially change the global financial system. + +## **From a Rolex to Global Financial Plumbing** + +What could Bitcoin become? Not just a Rolex, but the fundamental infrastructure of our economy. + +“When we buy groceries, when we buy a cup of coffee, when we send remittance and cross-border payments, when we take a loan, buy assets… these things can and should be built on an infrastructure that is based on Satoshi’s core principles,” Eli envisions. + +Gareth passionately agrees, recounting conversations with Bitcoin pioneers like Adam Back and citing the work of journalists who have seen Bitcoin used as a lifeline in countries ravaged by hyperinflation. In these places, Bitcoin is not an investment—it’s a payment network. It’s doing what it was designed to do. The goal of scaling is to bring that utility to everyone. + +## **Satoshi’s True Invention: The Three Pillars of a New Social System** + +Towards the end of the episode, Eli unpacks the core ideas from an article he wrote, “Satoshi’s Invention.” He argues that Satoshi’s true innovation wasn’t just about math or computers—it was a revolutionary new way to build **social constructs** like money. This new method stands on three powerful principles: + +1. **Broadness:** Everyone is invited to participate in operating the system. This is a stark contrast to the traditional financial world, where participation is exclusive and permissioned. +2. **Incentivized Integrity:** The system rewards participants for behaving honestly. Miners are given new Bitcoin for securing the network, creating a system where everyone has a vested interest in its integrity. We are not asked to trust people in suits; we are asked to trust a system of incentives. +3. **Public Verifiability:** Anyone, on a simple computer, can check every single transaction to ensure it was done with integrity. There are no hidden ledgers or backroom deals. + +These three principles—Broadness, Incentivized Integrity, and Public Verifiability—are what make Bitcoin revolutionary. They create a system based on individual empowerment and freedom. + +And this is where Eli’s work clicks into place. The technology behind Starknet exponentially expands that third pillar. “With enough math,” Eli explains, “you can use your laptop in order to verify the integrity of an exponential amount of computation… On your smartphone, within less than a second, you can verify the integrity of an amount of transactions that is all of the world’s transactions in a day.” + +This is the final piece of the puzzle, enabling Bitcoin to scale to a global level while holding fast to the principles Satoshi laid out. It’s how Bitcoin moves from being a Rolex to becoming the payment network for the world. + +--- +Sources: + - https://www.starknet.io/blog/starknet-foundation-delegation-program/ +--- + +## Starknet Foundation Delegation Program: How to apply + +Home  /  Blog + +Jul 17, 2025 · 3 min read + +As Starknet continues its decentralization journey and moves closer towards a Proof of Stake (PoS) protocol, contributors across the ecosystem are working together to support the growth of a strong, decentralized validator set. This is a critical bootstrapping moment: wide participation in staking and validation is imperative to safeguarding the network against the undue influence of any single entity, which is essential for a strong, permissionless, and truly decentralized system. + +Delegation programs play a key role in this process by lowering the barrier to entry for validators, encouraging broader participation, and improving decentralization. + +## The Starknet Foundation Delegation Program + +This week, the Starknet Foundation launched the Starknet Foundation Delegation Program (SFDP), a strategic initiative designed to enhance staking distribution, support validator growth and diversity, and strengthen network resilience. + +The program creates new opportunities for both new and existing validators to participate in securing the network. As such, there is clear, meaningful support and well-defined performance benchmarks. + +Let’s take a closer look at how the program works, who it supports, and what to expect. + +## Program details + +At its core, the Starknet Foundation Delegation Program is about broadening participation and improving resilience. Starknet’s validator set has grown, but we can and should do better for the health of the network and ecosystem. The program addresses the growth of staking delegation by introducing delegation mechanics and targeted validator support. + +The program’s goals are clear: distribute stake across a more diverse validator set; increase the number of active validators securing the network; upgrade overall staking participation to improve network security in the long-term. + +And it does this with a design philosophy built around three principles: + +* **Fair** – Balance decentralisation goals with responsible treasury management +* **Targeted** – Prioritise measurable, meaningful outcomes +* **Flexible** – Built to evolve alongside the network and its needs + +## How it works + +The Foundation will match validator stake 1:1, up to a maximum of 5 million STRK per participant, subject to performance criteria, such as: + +* **Stake Matching:** For STRK staked by a validator, the Foundation will delegate the same amount (up to 5M STRK), excluding any amount received from other Delegation Programs. +* **Residual Delegation**: Any remaining STRK in the delegation pool may be distributed evenly amongst qualified participants, i.e. + +* Stake 30M STRK → receive 5M delegated STRK matched + residual share. +* Stake 1M STRK → receive 1M delegated STRK matched + residual share. + +* **Program Cap:** If the delegation pool is exhausted, the Foundation will reduce stake matching allocations to all validators by the same proportional percentage. + +These mechanisms support validators who have secured meaningful stake independently, while also encouraging new participants to grow with the ecosystem. + +### Who is eligible? + +To receive matched delegation, validators must: + +* Run a full Starknet validator node. +* Maintain high uptime (>99%) and responsiveness. +* Respond to Foundation inquiries within 48 hours. +* Set commission rates at 10% or less. +* Meet regulatory compliance requirements + +**Validators remain eligible even if they participate in other Delegation Programs; however, any delegation received through those programs will be excluded from the matched stake calculation**. Validator performance will be monitored continuously, and delegated amounts will be adjusted regularly. + +### Application + +To apply, fill out the Starknet Foundation Delegation Program application form. Reviews will take place on a rolling basis. + +## Designed with adaptability in mind + +The program is built to adapt. During the program’s rollout, community feedback will be ensured with clear, transparent communication from the Foundation. + +## What are the next steps? + +The Starknet Foundation Delegation Program is an important moment in Starknet’s path toward deeper decentralization. It’s not just a validator incentive, it’s a strong signal to our ecosystem that STRK is here to do more. + +If you’re a validator – or ready to become one – now is the time to join us in building a more diverse and resilient Starknet. + +If you apply to the Starket Foundation Delegation Program, stay tuned to your inbox for updates from the Starknet Foundation. + +Let’s build a more resilient Starknet, and reshape the digital world together. + +*Note: This program does not constitute a grant, investment, or form of compensation. Delegated STRK remains under Foundation custody and is subject to revocation based on validator behavior. The program operates at the sole discretion of the Foundation and may be modified at any time to promote broader inclusion, fairness, and alignment with ecosystem goals.* + +--- +Sources: + - https://www.starknet.io/blog/the-rise-of-crypto-payments/ +--- + +## The rise of crypto payments: Easier, faster and more fun + +Home  /  Blog + +Share this post: + +Apr 24, 2025 + +Can crypto payments be as easy as tapping on your phone? Host Nathan and co-host Gareth team up with Stefana Banciu, growth lead at Pulsar Money, to explore how blockchain is revolutionizing payments, making them faster, cheaper and even fun. + +Stefana shares new innovative ways of sending crypto directly on X, transforming giveaways and cross-border transfers with transparency and ease. No jargon, just straight talk on why crypto payments could change your wallet. This episode was edited and produced by Tonal Media. + +In the following post, we’ll summarize the key insights from **Episode 5 of The Clear Crypto Podcast**. This episode tackles one of the most fundamental and anticipated use cases for blockchain technology: day-to-day payments. Can crypto ever truly replace the convenience of tapping a card or using a payment app? The hosts, journalist Nathan Jeffay from StarkWare and Gareth Jenkinson, Managing Editor of Coin Telegraph, are joined by a pioneer who believes it can—and that it can even be more intuitive and fun. We dive deep into the conversation with Stefana Banciu, co-founder of Pulsar Money, to explore the future of how we exchange value. + +## **The State of Play: Why Aren’t We Buying Coffee with Crypto?** + +The podcast kicks off with a dose of reality from Gareth, who, from his vantage point on the front lines of crypto media, confirms a hard truth: we’re not quite there yet. “I wish that I could say yes,” he admits, “but that would probably not be a true reflection of the state of affairs.” While some users leverage crypto-linked Visa or MasterCard services, the dream of tapping a native crypto wallet to pay for your morning coffee or groceries remains largely on the horizon. + +Why is this? Nathan points to a major hurdle: **convenience**. The perception—and often, the reality—is that traditional payment systems are simple and frictionless, while crypto is complicated, stressful, and unintuitive. + +Gareth adds another layer of perspective, drawing a parallel to a technology we now take for granted. “I even just look at how long it took people to begin using tap services with conventional cards and mobile devices,” he reflects. He recalls his own initial reluctance to adopt “tap-and-go” services, a sentiment shared by many who were wary of the new technology. “Now I can’t even imagine life where I wasn’t just tapping my mobile phone at every service point.” + +This analogy is powerful. It reminds us that user adoption is a gradual process built on overcoming fear and demonstrating clear benefits. The journey from swiping to tapping wasn’t instantaneous, and the shift to crypto payments will likely follow a similar path of innovation and trust-building. The key is for developers and builders in the space to create products that are so compellingly simple and useful that the transition becomes inevitable. + +## **A New Vision for Payments: Making Crypto Fun and Social** + +This is where Stefana Banciu and her work at Pulsar Money enter the conversation. Stefana isn’t just trying to replicate the existing payment experience on the blockchain; she’s reimagining it. Pulsar Money’s mission is to spearhead the “future payments narrative” within crypto, and their strategy is refreshingly unconventional. + +“What we are trying to do with Pulsar… is to run this future payments narrative within crypto,” Stefana explains. The core of their approach is to blend utility with enjoyment, onboarding users through fun, social interactions that seamlessly introduce them to the power of crypto payments. + +#### **The Twitter Tipping Point** + +The flagship example of this philosophy is Pulsar’s social payments module. Stefana describes a feature that feels like magic to many crypto veterans and newcomers alike: the ability to send money directly within a social media platform like X (formerly Twitter). + +“You can actually send funds directly on Twitter,” she says. “I can just tag your Twitter handle and I can directly send you funds through it.” + +This isn’t just a gimmick. It’s a brilliant strategy to lower the barrier to entry. Instead of navigating complex wallet addresses and QR codes, a user can perform a familiar action—tagging someone—to initiate a real financial transaction. The process is seamless, public, and engaging. + +“We said, ‘Okay, why not? We think of a way on how we can onboard the users, make them do payments, you know, in a fun way.’ And this was the strategy for us from the beginning,” Stefana adds. + +This approach resonates deeply with Gareth, who recognizes the power of community in the crypto space. “A lot of our industry is driven by communities and engagement,” he notes. “You need to think of innovative ways to get people involved in order to use your product or service.” + +Pulsar’s model is a masterclass in user-centric design. It takes a potentially “boring” topic like payments and injects it with the social dynamics that already drive massive engagement online. By doing so, it educates users about the possibilities of crypto without them even realizing they’re learning. + +## **Under the Hood: The Technology Making It Possible** + +How can Pulsar Money offer instant, low-cost transactions that are suitable for social “micro-payments”? The answer lies in advanced blockchain infrastructure, specifically **layer 2** scaling solutions. + +A **layer 2** network is a protocol built on top of a main blockchain (like Ethereum), which is known as layer 1. Its purpose is to handle transactions off the main chain, allowing it to process them much faster and at a fraction of the cost. It then bundles these transactions together and records a compressed summary back to the secure layer 1. This process, often utilizing technology like ZK-Rollups, allows a platform to achieve massive scale without sacrificing the security and decentralization of the underlying blockchain. + +Pulsar Money leverages **Starknet**, a leading layer 2 ZK-Rollup, to power its services. By building on Starknet, Pulsar can ensure that sending a small tip on Twitter doesn’t get bogged down by high network fees or long confirmation times, which would make such a use case impractical on layer 1. This technological foundation is what enables the seamless, fun, and scalable user experience that Stefana and her team have envisioned. + +## **Beyond Convenience: Why We Need Crypto Payments** + +The conversation then pivots to a more fundamental question: with services like PayPal and Venmo already offering instant digital payments, why do we need a crypto-based alternative? Stefana and Gareth lay out the core value proposition of blockchain payments, which goes far beyond just moving money from A to B. + +Stefana begins by revisiting the original promises of crypto: “low money fees and borderless payments.” But the list of advantages runs much deeper: + +* **Permissionless Transfers:** You don’t need approval from a bank or third party to send or receive funds. +* **Speed and Low Cost:** Especially on layer 2 solutions, transactions can be nearly instantaneous and cost pennies. +* **Censorship Resistance:** No central authority—be it a bank or a government—can block your transaction or freeze your funds. +* **Financial Sovereignty:** You have ultimate control over your own money. This is the principle of **self-custody**. + +Gareth powerfully emphasizes this last point. For him, the “why” of crypto payments boils down to ownership. “Cryptocurrency payments are important because you have control of your money, you have control of your keys,” he states. “You don’t have to ask permission to use or send that money, and no one can stop you from doing it if it’s a truly decentralized network… It comes down to these ideals of freedom and censorship resistance.” + +#### **The Case for Self-Custody: Lessons from Recent History** + +The hosts agree that in a world that can be turbulent and unpredictable, relying on traditional intermediaries carries inherent risks. They discuss real-world events that underscore the importance of financial self-sovereignty: + +1. **The Cyprus Banking Crisis (2013):** During a severe financial crisis, the government of Cyprus closed banks and imposed capital controls, limiting citizens’ access to their own savings. This event served as a stark reminder that money in a bank isn’t always fully under your control. +2. **The Silicon Valley Bank (SVB) Collapse (2023):** This more recent example hit closer to home for the crypto industry. When SVB failed, it was revealed that Circle, the issuer of the major **stablecoin** USDC, held around $3.3 billion of its cash reserves at the bank. + +A **stablecoin** like USDC is a type of cryptocurrency designed to maintain a stable value, typically by being pegged 1:1 to a real-world asset like the US dollar. For every USDC token in circulation, Circle is supposed to hold one US dollar (or equivalent cash asset) in reserve. + +When SVB collapsed, that $3.3 billion was suddenly at risk, meaning a significant portion of the reserves backing USDC was inaccessible. This triggered a panic, causing USDC to temporarily lose its 1:1 peg to the dollar. As Gareth puts it, “If that’s not a great example of why you need to have self custody of your money… I don’t know what is. If a bank can fail or a government can stop you from spending your money, do you really have control of that money? I don’t think so.” + +These examples illustrate that crypto payments aren’t just about a new way to pay; they represent a fundamental shift in our relationship with money, moving from a model of trusted third parties to one of verifiable self-ownership. + +## **The Power of Transparency: A Crypto Solution to an Old Problem** + +Building on the theme of verification, Stefana explains another tangible benefit of Pulsar’s social payment system: **transparency**. She uses the common example of social media giveaways. + +We’ve all seen them: posts promising a huge prize to a lucky follower who likes, shares, and comments. But there’s always a lingering suspicion. Was the prize ever really given away? Was the winner a real, random person, or a friend of the organizer? + +With a blockchain-based system, this ambiguity disappears. + +“With the social pay, you can actually do this directly on Twitter in a super transparent way,” Stefana explains. “It’s super visible for everyone. You could check it on-chain… where the funds or the prize is really distributed. There’s no need to ask for wallets to transfer this manually. Everything is on-chain and then everything is transparent on social media.” + +This creates a powerful bond of trust between a brand or influencer and their community. The community knows that the giveaway is legitimate because the proof of the prize distribution is public, immutable, and easily verifiable on the blockchain. + +Gareth, whose Coin Telegraph X show runs its own giveaways, immediately sees the value. “I find it fantastic that I’m now hearing about this,” he exclaims. “I think it is something that social media really needs… the one thing that’s missing in that ecosystem is the ability to make payments.” This use case, while seemingly small, perfectly demonstrates how blockchain’s core properties can solve everyday problems of trust and verification. + +## **Banking the Unbanked: Moving Beyond the Buzzword** + +The conversation broadens to one of crypto’s most touted, and sometimes criticized, promises: “banking the unbanked.” Is this a genuine goal or just a tired cliche? + +Gareth, who grew up in South Africa, offers a grounded perspective. “I don’t think it’s a cliche,” he asserts. “If you look at where I come from… being unbanked is a huge problem.” + +He explains the very real barriers that prevent billions of people from accessing traditional financial services: + +* Lack of a formal ID. +* No fixed address or proof of residence. +* No title deeds to the land they live on. + +Without these documents, opening a bank account is impossible. This is where crypto offers a revolutionary alternative. “You can do it with a phone that’s not a smartphone, just a very simple mobile phone and an SMS service,” Gareth explains. “You can get people onto the Bitcoin network and send them some sats.” + +A crypto wallet doesn’t require permission, an ID, or a credit check. It gives anyone, anywhere, the ability to receive, store, and send value, granting them a foothold in the global economy. Nathan adds that StarkWare itself is actively investing in this vision, with a dedicated team working on projects in Africa. The realization is that the most profound crypto breakthroughs may not happen in developed nations, where people have viable alternatives, but in regions where there is a pressing, day-to-day need for a new financial system. + +## **News Spotlight: The Solo Miner Who Hit the Jackpot** + +To cap off the episode, Gareth shares one of his favorite recent news stories—a tale that perfectly captures the spirit of crypto’s decentralization. Twice in the span of six weeks, a solo Bitcoin miner managed to solve a block and claim the entire block reward. + +To understand the significance, here’s a quick primer on Bitcoin mining: + +* **Mining:** The process by which transactions are verified and added to the Bitcoin blockchain. It involves computers (miners) solving complex mathematical problems. +* **Mining Pools:** Because the problems are so difficult to solve, most miners pool their computational power together. When the pool solves a block, they share the reward proportionally. This is like a lottery pool—you have a much higher chance of winning a small piece of the prize. +* **Solo Mining:** A solo miner competes against the entire network, including the massive pools, using only their own hardware. Their chance of solving a block is infinitesimally small, akin to buying a single lottery ticket for a massive jackpot. + +Incredibly, one of these solo miners, using a tiny, low-power piece of hardware, beat the odds. They successfully solved a block and walked away with the full reward of 3.125 Bitcoin, worth approximately $300,000 at the time. “The odds of this are like a million to one,” Gareth marvels. + +This story is more than just a lucky break. It’s a beautiful demonstration of the Bitcoin network’s incentive structure and its core ethos. It proves that even today, with mining dominated by large operations, the network is still open. Anyone can participate, and anyone has a chance—however small—to win. It’s a powerful reminder that at its heart, crypto is for everyone. + +## **Conclusion: The Path Forward for Payments** + +This episode leaves us with a sense of optimism and excitement. The road to mass adoption of crypto payments is still being paved, but innovators like Stefana Banciu are laying the groundwork with solutions that are not just technologically sound but also human-centric. + +By focusing on user experience, blending payments with social engagement, and leveraging the power of layer 2 technology like Starknet, companies like Pulsar Money are showing that crypto payments can be more than just a niche alternative. They can be easier, more transparent, and fundamentally more empowering than the systems we use today. From securing our financial sovereignty to bringing billions into the global economy, the future of payments is being built on the blockchain, one fun, transparent, and revolutionary transaction at a time. + +--- +Sources: + - https://www.starknet.io/blog/unlocking-bitcoins-new-powers/ +--- + +## Beyond digital gold: Unlocking Bitcoin’s new powers + +Home  /  Blog + +Share this post: + +May 8, 2025 + +What’s driving Bitcoin’s evolution from digital gold to a global financial powerhouse? Host Nathan and co-host Gareth sit down with Bitcoin OG Dan Held, a trailblazer since 2012, to unpack Bitcoin’s journey and its bold future. + +Dan dives into how innovations like DeFi and layer-2 solutions are expanding Bitcoin’s potential, while navigating community debates over NFTs and scaling. No jargon, just straight talk on why Bitcoin’s moment is now. Whether you’re new or a seasoned hodler, this one’s for you. Produced by Tonal Media. + +In the following post, we’ll summarize the sixth episode of the Clear Crypto Podcast. In this enlightening conversation, hosts Nathan Jeffay and Gareth Jenkinson are joined by Dan Held, a pivotal figure in the Bitcoin world. Dan, a serial entrepreneur and one of the most respected educators in the space, was there in the early days and offers a unique perspective on Bitcoin’s tumultuous past, its vibrant present, and its incredibly promising future. From the philosophical roots of the 2008 financial crisis to the technical debates shaping Bitcoin’s next chapter, this discussion is a must-read for anyone curious about the world’s first and most important cryptocurrency. + +### **A Snapshot of Crypto Today: From the Fringes to the Forefront** + +To kick things off, Dan Held paints a picture of the current crypto landscape, and for seasoned veterans, it’s an unusual one. “It kind of feels weird to be honest, where we’re not the bad guys,” he remarks. For years, Bitcoin was painted in the media as a tool for illicit activities, a speculative “pump and dump” asset, and an environmental menace. Today, the narrative has shifted dramatically. + +Dan points out that the current bull run is different from previous cycles. While the explosive retail frenzy hasn’t fully returned yet, this cycle has been marked by significant **institutional adoption**. Major financial players are now involved, and an estimated 25% of Americans already own Bitcoin. This isn’t a niche interest anymore; it’s a significant segment of the population. + +Perhaps the most significant change is the political climate in the United States. Dan describes the current administration as the “most open… towards Bitcoin” in its history. This is a seismic shift from previous years, where regulatory pressure and hostility from government bodies were a constant threat. This newfound openness in the U.S., a global leader in financial regulation, sets a positive tone for the rest of the world. + +Gareth adds that this move towards acceptance is about more than just price. It’s about freedom. “People are now having the freedom to have a protocol that allows you to transfer value, peer-to-peer, trustlessly, without a third party to tell you you can or can’t,” he explains. This shift allows for the development of tools and services that give individuals ultimate control over their money—the fundamental promise of Bitcoin from day one. + +### **The Time Machine: A Journey to Bitcoin’s Origins** + +To understand where Bitcoin is going, it’s crucial to understand where it came from. Dan Held’s journey into crypto is a perfect illustration of the mindset that first embraced this revolutionary technology. His story didn’t start with a hot tip or a desire for quick profits; it began in the ashes of the 2008 financial crisis. + +“I was studying finance… during the 2008 financial crisis,” Dan recalls. “Everyone that I was listening to, whether it be professors, TV, and the books I was reading, they were all wrong.” The system he was taught to believe in had failed spectacularly, shattering the trust it was built on. This experience “radicalized” him, pushing him toward alternative economic theories like the Austrian school of economics, which advocates for minimal government intervention in money. + +When he first heard about Bitcoin in 2011, his mind was already primed for its message. He was, in his own words, the “perfect product-market fit.” Even so, the barrier to entry was immense. There were no user-friendly apps or detailed tutorials. Getting started required technical help from an engineering friend. + +Dan likens the complexity of early Bitcoin to an old-world pharmacy where the apothecary had to manually mix ingredients to create medicine. This friction, however, was also the opportunity. “The friction in understanding Bitcoin and the friction in using it is the alpha, like that’s it,” he states. The core code of Bitcoin hasn’t changed much since then; what has changed is the world’s understanding and recognition of its value. + +### **The “Aha” Moment: Why the 21 Million Cap Is Everything** + +For many early adopters, there was a single moment when Bitcoin’s true potential clicked into place. For Dan, that moment was discovering its monetary policy. + +“The breakthrough moment for me… was the monetary policy, the 21 million hard cap. That was it.” + +What does this mean? + +* **A Fixed Supply:** There will only ever be **21 million Bitcoin** created. This number is encoded into the protocol and cannot be changed without overwhelming consensus from the entire network. +* **Predictability and Trust:** This fixed supply makes Bitcoin’s monetary policy perfectly simple, transparent, and trustworthy. You know exactly how many Bitcoin exist today and how many will exist in the future. +* **The Opposite of Fiat:** This stands in stark contrast to government-issued fiat currencies like the dollar, euro, or pound. Central banks can (and do) print more money whenever they see fit. This continuous increase in supply is what we call inflation, and it’s why your money buys less and less each year. We’ve become accustomed to our savings losing value over time, but as Dan points out, this wasn’t always the case. Under the gold standard, money largely held its value for centuries. + +The 21 million hard cap makes Bitcoin a true store of value. As more people lose faith in the ever-inflating supply of fiat money, they seek refuge in an asset with a fixed, unchangeable quantity. This migration of belief is what gives Bitcoin its value. + +### **The Future is Layered: Scaling Bitcoin for Mass Adoption** + +While Bitcoin’s role as “digital gold” is its foundational value proposition, many in the community, including Dan, believe it can be much more. To reach its full potential and serve a global population, Bitcoin needs to be able to handle a much higher volume of transactions than its base layer currently allows. This is where the concept of **scaling in layers** comes in. + +“With Bitcoin on the base layer, we’re never gonna be able to do every transaction in the world,” Dan explains. “There’s too many people, not enough space.” + +This was the central issue in the “block size wars” of 2017, a fierce debate that led to the creation of Bitcoin Cash. The community that prevailed—what we now know simply as Bitcoin—agreed that the solution wasn’t to make the base layer bigger, but to build on top of it. + +This is where Layer 2 (L2) solutions come into play. Think of the Bitcoin base layer (Layer 1) as a global settlement network for large, important transactions, like an international bank wire. It’s secure and final, but it’s not designed for buying a cup of coffee. A Layer 2 is like a faster, cheaper network built on top, similar to how PayPal or Venmo facilitate countless small payments that are later settled in the traditional banking system. Companies like **Starknet**, are at the forefront of developing these L2 technologies. + +Dan’s vision is to bring the dynamic financial activities seen on other blockchains—often called Decentralized Finance (DeFi)—back to Bitcoin via these L2s. This includes activities like lending, borrowing, and staking. He argues that while some purists dislike speculation, it’s often the gateway for new users. “Most people come for the speculation, and then they stay for the sound money,” he says. By enabling these financial primitives on Bitcoin L2s, the ecosystem can attract a new wave of users who will ultimately discover and benefit from Bitcoin’s core properties. + +### **A House Divided? The Great Debate on Bitcoin’s Evolution** + +Innovation is rarely straightforward, and Bitcoin is no exception. The push to expand Bitcoin’s capabilities has created a fascinating and sometimes contentious debate within the community. Dan divides the two main camps into “Bitcoin Puritans” and “Bitcoin Moderates.” + +* **The Puritans:** This group believes Bitcoin’s primary and perhaps only legitimate use is for simple peer-to-peer payments. They often view other activities, like NFTs (or Ordinals) and complex financial applications, as a misuse of the blockchain’s precious block space. As Dan puts it, their motto is essentially, “Stay off my blockchain.” +* **The Moderates:** This group, which includes Dan, advocates for an open, free-market approach. They believe that as long as you pay the transaction fee, you should be able to use the Bitcoin network for any purpose you see fit, adhering to the original ethos of free-market principles. + +This debate isn’t just philosophical; it has real technical implications. The Moderates are advocating for small, carefully considered upgrades to Bitcoin’s code, known as “soft forks.” A soft fork is a backward-compatible change, meaning users can opt-in to the new rules without splitting the network (unlike a “hard fork,” which created Bitcoin Cash). + +One such proposed upgrade, OP\_CAT, would reactivate a piece of code that was originally in Bitcoin but was later disabled by Satoshi Nakamoto. This simple change could dramatically improve the functionality and security of the **crypto bridge** technology that connects Bitcoin’s base layer to the various L2s. A stronger, more trustless bridge would make the entire layered ecosystem more secure and efficient, fulfilling the vision of scaling that the community agreed upon years ago. + +### **An Optimistic Future: Consensus, Innovation, and Sound Money** + +Despite the internal debates, the overarching sentiment is one of immense optimism. As Gareth beautifully summarizes, the beauty of Bitcoin is that “consensus rules.” No single person— not a developer, not a company—gets to decide Bitcoin’s future. The network’s participants, through a process of social consensus, will ultimately determine its path. + +The journey has been long and filled with challenges, from civil wars within the community to external attacks from governments. Yet, Bitcoin has not only survived but thrived, proving its resilience and antifragility. + +“The future looks really bright,” Gareth concludes. “And I have no doubt in five years we will have solved many of these problems and we will have a fantastic sound monetary base to use. That’s completely digital, that’s completely peer-to-peer and has no central authority managing it. And that for me, makes me really, really optimistic for the future.” + +The conversation with Dan Held serves as a powerful reminder that we are witnessing a remarkable experiment unfold in real-time. From a radical idea born out of financial crisis to a global asset class on the cusp of mass adoption, Bitcoin’s story is just getting started. + +--- +Sources: + - https://www.starknet.io/blog/extended-live-on-starknet-mainnet-hyper-performant-perp-dex/ +--- + +## Extended Live on Starknet Mainnet: Hyper-Performant Perp DEX + +Home  /  Blog + +Aug 12, 2025 · 2 min read + +We’re excited to announce that Extended, formerly known as X10, is now live on Starknet mainnet. This marks a major leap forward for both the Extended protocol and the Starknet DeFi ecosystem. + +Explore Extended now + +## Why Starknet? + +Originally deployed on StarkEx, Extended has proven itself as a fast and efficient platform for perpetual trading. But now, it’s entering a new era of composability with Starknet’s growing ecosystem. By migrating to Starknet, Extended takes full advantage of a composable and trustless environment, settling trades directly onchain with the power of STARK proofs. This allows transactions to settle both quickly and cheaply. This is more than just an upgrade; it’s a fundamental change that establishes Extended as a crucial component within Starknet’s expanding DeFi ecosystem. + +## Extended: Onchain Trading & Cross-Chain Accessibility + +For DeFi traders already active on Starknet, Extended offers a powerful new tool to trade onchain. With lightning-fast settlement and direct mainnet deployment, it’s now easier than ever to access deep liquidity, explore diverse trading pairs, and manage capital with more flexibility. And for users who previously traded on Extended via StarkEx, the migration means a better user experience, faster and cheaper withdrawals, and direct access to Starknet-native liquidity. + +Extended also opens the door for traders across the broader crypto landscape. With full support for EVM-compatible wallets, anyone can now connect with MetaMask, WalletConnect or a Starknet-native wallet and start to trade with Extended on Starknet. The team is actively building a direct on-ramp from other chains, so users can onboard to the perp DEX without any friction. This approach dramatically lowers the barrier to entry and unlocks new pathways for cross-chain DeFi participation. + +Traders can now explore **more than 50 perpetual markets on Extended**, with leverage **numbers available** **here**. And this is just the beginning. Extended is now building the foundation for unified margin logic with integrated lending and spot markets to support non-stablecoin collateral, including yield-bearing assets. Extended also developed **onchain vaults**, including infrastructure that will eventually support **Bitcoin-based Vault strategies** on Starknet. + +These features aim to create a comprehensive trading hub that merges performance with composability, making Extended not just another perps DEX, but a full-stack DeFi platform for Bitcoin and Ethereum users. + +Extended’s perps DEX is not accessible to US users. + +Read more about Starknet’s long-term vision for Bitcoin + +## Starknet: The Future of High-Performance DeFi + +Launching on Starknet mainnet is a statement. It reinforces Starknet’s role as a high-performance settlement layer 2 where serious DeFi can thrive. Extended proves that robust, scalable trading protocols can be built without compromising on decentralization, security, or user experience. + +Discover more dApps on Starknet + +--- +Sources: + - https://www.starknet.io/blog/crypto-payments-future/ +--- + +## Crypto payments future: Self-custody and mass adoption + +Home  /  Blog + +Share this post: + +Aug 3, 2025 + +What’s keeping blockchain from the mainstream and how do we sell it to the world? Host Nathan and co-host Gareth chat with Chad West, CMO of ArgentHQ, about the hurdles to mass adoption — cost, complexity, perception — and how ArgentHQ is tackling them with user-friendly wallets and smart marketing. + +Chad reveals how to make self-custody and payments feel effortless. No jargon, just straight talk on crypto’s big moment. Whether you’re new or a seasoned hodler, this one’s for you. This episode was edited and produced by Tonal Media. + +In the next few lines, we’ll summarize the 4th episode of the Clear Crypto Podcast, a deep dive into one of the most pressing challenges facing the blockchain world today. Can crypto finally shed its reputation for being clunky, intimidating, and complicated? Can it deliver the kind of seamless, intuitive user experience we’ve come to expect from the slickest apps on our phones? + +For a technology that promises a new era of financial sovereignty and digital ownership, the user experience has often felt stuck in the past. Newcomers are frequently greeted with a barrage of jargon, terrifyingly long hexadecimal addresses, and the constant fear that one wrong click could send their funds into the digital abyss. For a technology to go mainstream, it must feel safe, simple, and empowering. + +That critical transformation is finally underway. In this episode, host Nathan Jeffay sits down with Gareth Jenkinson, Managing Editor of Cointelegraph, and a guest uniquely positioned to bridge the gap between traditional finance and the decentralized future: **Chad West**. As one of the earliest employees at Revolut, the fintech behemoth that redefined how millions manage their money, Chad was instrumental in building a platform synonymous with user-friendliness. Today, he’s applying those same hard-won principles to the world of crypto with Ready (formerly Ready), a next-generation self-custodial crypto wallet built on the powerful **Starknet** layer 2 network. + +This conversation isn’t just about incremental improvements; it’s about a fundamental reimagining of how we interact with our digital assets, making crypto not just powerful, but practical and accessible for everyone. + +### + +## **From Fintech Darling to Crypto Pioneer** + +To understand where crypto’s user experience is headed, it’s essential to look at the revolution that preceded it in financial technology. Before exploring the innovations at Ready, Nathan asked Chad to reflect on his journey at Revolut, a company that became a household name by solving problems that traditional banks had ignored for decades. + +“I was employee number 12 at Revolut,” Chad shared, painting a picture of the company’s humble origins. “I headed up all things growth, marketing, and comms for five years, from a tiny little workspace… to probably the highest valued FinTech company in the world right now.” + +Revolut’s initial masterstroke was its travel card, which eliminated predatory foreign exchange (FX) fees. Anyone who had ever traveled or sent money internationally knew the pain: opaque fees, poor exchange rates, and multi-day waiting periods for wire transfers. Revolut replaced that entire frustrating process with a simple card and an elegant app. This masterclass in solving a clear user pain point gave them their initial product-market fit. But the vision was always far grander. + +“Revolut’s goal was always to essentially build the WeChat of the West,” Chad explained. “This one app where you could do everything finance, from your banking to crypto, to stocks, to booking flights and accommodation, you name it.” This concept of a financial “super-app” was brought to life through a relentless focus on a simple, intuitive user experience. Revolut took complex operations—like stock trading, commodity investing, or buying cryptocurrency—and distilled them into a single tap. + +Interestingly, it was Revolut’s entry into crypto during the 2017 bull run that provided a key lesson. “The numbers were just insane,” Chad recalled. Users flocked to the platform because it offered a trusted, one-tap way to buy Bitcoin and Ethereum, running for the hills when they looked at the complex interfaces of traditional crypto exchanges. “Even though Revolut’s fees were a little bit higher than traditional exchanges, people were happy to pay that 0.5% more for that ease of use, but also for the trust.” This proved a critical point: users will pay for simplicity and a name they trust. It’s this exact philosophy that Chad now brings to his work at Ready. + +### + +## **The Bedrock Principle: Why Self-Custody is Everything** + +Before diving into how Ready is building a “Revolut for crypto,” it’s crucial to understand a foundational concept that defines true digital ownership: **self-custody**. + +Gareth Jenkinson laid it out perfectly. “The backbone of the cryptocurrency space is really built on the idea of what Bitcoin brought. And a big part of that is actually having ownership of the financial asset that you’re holding,” he explained. + +To grasp the difference, consider an analogy. Using a centralized exchange is like keeping your gold in a bank’s vault. It’s convenient, and they handle the security. But you are trusting them. You don’t hold the key to the vault. If the bank mismanages its business, gets robbed, or decides you’re no longer a customer they wish to serve, your access can be cut off. You’re asking for permission to access what you own. + +This is the custodial model. The exchange holds your private keys for you. As we saw with the catastrophic collapse of FTX, this trust can be broken. “All it takes is some dodgy business to be going on the back end there. And you’ve lost everything as people did,” Chad stated grimly. The FTX scandal, where billions in user funds vanished overnight due to fraud and mismanagement, was a brutal lesson in the risks of centralization. The phrase “not your keys, not your coins” became a painful reality for millions. + +In contrast, self-custody is like having that gold in a high-tech safe in your own home. You hold the key. No one else. This is the model of a self-custodial wallet like Ready. You hold your own private keys, giving you absolute and final control over your funds. + +After FTX, many expected a mass exodus to self-custody. While there was a spike, it wasn’t the total industry shift some had predicted. Gareth pointed to the reason: **convenience**. “I am still quite surprised that a lot of people still just leave a load of crypto on exchanges,” he admitted. “My general opinion is that most people don’t find it convenient enough to hold cryptocurrency in a self-custodial manner. That, for me, is the biggest takeaway.” The anxiety of managing a seed phrase, the complexity of interacting with decentralized applications (dApps), and the fear of making an unrecoverable error were significant barriers. This friction point is precisely what Ready is engineered to eliminate. + +## **Building a Revolut for Crypto: The Ready Mission** + +Chad’s move from fintech to crypto was driven by a powerful ideology, born from witnessing the fragility of access in the traditional system. + +“I saw firsthand in regulated, centralized finance, how just having the wrong opinion or putting the wrong tweet out there could immediately see all of your funds be [frozen],” Chad said. This can happen to political dissidents, activists, or even freelancers in countries with unstable regimes. “That just shocked me. For me, having a bank account is basically like a human right. It’s impossible to function in today’s world without having one.” + +This conviction is the driving force behind Ready. The mission is to deliver the promise of self-custody—where your right to transact cannot be taken away—without the scary, user-hostile experience. When you give your crypto to a centralized exchange, you’re placing it in a “black box.” You have no visibility into their risk management or internal security. You just have to trust them. + +“No central bank, no regulator, no government can come in and say, ‘Hey, freeze Nathan’s self-custody wallet.’ Even if they wanted to, they physically can’t,” Chad explained. This is the power of a decentralized network. But to bring this power to the mainstream, the experience has to feel as safe and simple as the best fintech apps. + +## **Beyond the Seed Phrase: Innovating on Security and Usability** + +For over a decade, self-custody was synonymous with the seed phrase: a list of 12 or 24 words you had to write down and protect with your life. Lose it, and your crypto was gone forever. It was a terrifyingly fragile system and a non-starter for mass adoption. + +“We don’t really believe that seed phrases are the future,” Chad stated unequivocally. Ready is pioneering a new model built on the advanced capabilities of the **Starknet** layer 2, specifically a technology called **account abstraction**. + +Account abstraction is a paradigm shift for wallets. In a traditional crypto account, your account *is* your key. They are fused together. Account abstraction separates them. This means your account (your address on the blockchain) can be controlled by more flexible rules, not just a single, rigid private key. This opens the door to a host of user-friendly features that were previously impossible. + +1. **Social Recovery with Guardians:** This is Ready’s answer to the lost seed phrase problem. Instead of a single point of failure, you can designate “Guardians”—which can be trusted friends, family members, or even other hardware or software wallets you own. If you lose access to your primary device, you can use a majority of your Guardians to securely approve the recovery of your account. It’s a distributed, user-controlled recovery process that provides redundancy and peace of mind. “We’ve innovated in the past with solutions like guardians,” Chad noted, “whereby you can assign an individual or another wallet as a trust keeper of your Ready wallet.” +2. **Two-Factor Authentication (2FA):** We use 2FA everywhere—Gmail, banking, social media. It’s a standard security expectation. If a hacker gets your password, they are stopped by a second check. “Very basic, very standard, didn’t exist in crypto,” Chad said. “We were able to bring that into crypto [on Starknet].” With Ready, you can require a second, off-chain confirmation (like from your email) for high-value transactions. This familiar security layer makes users feel significantly safer. + +## **The Power of Layer 2: How Starknet Unlocks a Seamless Experience** + +These sophisticated features are only practical because Ready is built on **Starknet**, a leading **layer 2** **scaling solution**. Trying to implement these on Ethereum’s main network (Layer 1) would be slow and astronomically expensive due to high transaction fees, often called “gas.” + +Think of Ethereum Layer 1 as a congested city highway. Every car (transaction) has to pay a high toll (gas fee), and during rush hour, the traffic is gridlocked and tolls skyrocket. Layer 2s like Starknet are like a hyper-efficient mass transit system. Starknet uses advanced cryptography called **ZK-rollups** to bundle thousands of transactions together off-chain. + +To extend the analogy, a ZK-rollup acts like a giant, super-fast bus. It picks up thousands of passengers (transactions) in a special express lane (off-chain computation), validates all their tickets internally, and then presents a single cryptographic proof—like one master ticket—to the main highway tollbooth (Ethereum L1). This is vastly more efficient, resulting in dramatically lower fees and a faster user experience. + +This scalability is what makes account abstraction features feasible, but Starknet’s innovation doesn’t stop there. Chad also highlighted **session keys**, a feature set to transform interactive applications like gaming. + +“If we look at blockchain gaming, the experience was terrible,” he said. “Every time you performed an action like swinging a sword, you would have to approve that transaction and pay a fee.” This stop-start experience destroyed the flow of gameplay. **Session keys** solve this by allowing a user to approve a “session”—for example, granting a game permission to perform low-stakes actions for one hour—without needing a constant stream of pop-up approvals. + +“By building on Starknet and utilizing tech like ZK-rollups, session keys, or account abstraction, we’ve been able to finally build that slick, smart wallet experience that we’re known for,” Chad concluded. + +## **Putting It All into Practice: The Crypto Nomad Debit Card** + +Advanced technology is only useful if it solves real-world problems. Ready’s recently launched self-custodial debit card is the perfect embodiment of their philosophy in action. + +“We’ve launched a debit card initially in Europe, and we’ve done it a little bit differently,” Chad said. The card is specifically designed for the **crypto nomad**. Gareth described this growing demographic as people who “espouse all the virtues of crypto and freedom technology… carrying all their money in a cryptocurrency wallet and living a very borderless lifestyle.” + +Imagine a freelance developer getting paid in a stablecoin to their Ready wallet. They can then use their Ready card to buy a coffee in Lisbon, pay for their apartment in Bali, and book a flight to their next destination in Bogotá—all seamlessly, spending directly from their self-custodied funds. + +The card’s features are purpose-built for this life: + +* **100% Self-Custody:** True ownership meets real-world spending. +* **Generous Cashback:** Up to 10% cashback on purchases. +* **No FX Fees:** Absolutely critical for a borderless lifestyle. +* **Crypto-Native Perks:** Valuable discounts on tools nomads already use, from VPNs and security services to travel booking sites. + +This card is more than a payment tool; it’s an enabler for a new way of living, powered by self-sovereign finance. + +## **The Road Ahead: Abstraction is the Destination** + +Gareth remains optimistic but clear-eyed about the journey ahead. The wounds from failures like FTX have made the argument for self-custody undeniable, but the ultimate victory depends on vanquishing the final boss: complexity. + +“The most important people in the industry are driving that ahead,” he said, “but there’s probably another five or 10 years until we really reach that final destination.” + +That final destination is a world of total abstraction. A world where users don’t have to think about which blockchain they’re on. “We need to stop thinking in terms of chains like Bitcoin, Ethereum, Solana,” Gareth mused. A user’s wallet should show a single, unified balance. When they go to pay for something, the wallet’s intelligence should automatically route the payment through the cheapest, fastest path—be it Starknet, another L2, or a different L1—without the user needing to know or care. It should just work. + +This is the holy grail: to combine the ironclad security and freedom of self-custody with an experience that is utterly effortless. Thanks to the vision of teams like Ready and the powerful, scalable foundation of layer 2 platforms like Starknet, that future is no longer a distant sci-fi concept. It’s being coded into existence today. + +--- +Sources: + - https://www.starknet.io/blog/bitcoin-season-2/ +--- + +## Bitcoin Season 2: Unlocking a New Financial Frontier - The Clear Crypto Podcast | Episode 8 | Starknet + +Home  /  Blog + +Share this post: + +Aug 12, 2025 + +What’s powering Bitcoin’s leap into a new era? Host Nathan and co-host Gareth join Isabel Foxen Duke, a Bitcoin innovator and general partner at Unbroken Chain, to explore “Bitcoin Season 2,” where ordinals, runes and trustless lending are redefining what Bitcoin can do. + +Isabel shares her journey from traditional finance to championing Bitcoin’s DeFi potential and unpacks how trustless bridging could shrink the financial world. No jargon, just straight talk on Bitcoin’s game-changing future. Whether you’re new or a seasoned hodler, this one’s for you. Produced by Tonal Media. + +In the 8th episode of The Clear Crypto Podcast, we journey beyond the familiar narratives of Bitcoin as digital gold or a peer-to-peer payment system. Guided by host Nathan Jeffay, Gareth Jenkinson from Coin Telegraph, and special guest Isabel Foxen Duke, GP of Unbroken Chain, VP of layer 1 Foundation, we step into a speculative but rapidly approaching future colloquially known as “Bitcoin Season 2.” This conversation peels back the layers on how the world’s first cryptocurrency could evolve from a straightforward monetary asset into a foundational layer for a new universe of financial applications. + +## What Exactly is “Bitcoin Season 2”? + +If “Bitcoin Season 1” was about establishing a decentralized, secure, and finite form of money, then “Season 2” is about unlocking its full potential as a programmable financial platform. The term, which Isabel Foxen Duke calls one of her favorites in the industry, represents a paradigm shift in how we think about Bitcoin’s utility. + +“Bitcoin season two is really about seeing what we can do with Bitcoin outside of just being money,” Isabel explains. “What are the broad range of financial use cases for this money other than just being money by itself? So things like lending, scaling faster transactions, cheaper transactions, all sorts of decentralized use cases.” + +For over a decade, Bitcoin’s core identity has been tied to its robust monetary policy. As Gareth points out, its protocol established a new form of “hard money”—finite, predictable, and resistant to inflation. While its price has been volatile, this is a natural part of its price discovery phase for an asset not yet two decades old. The underlying strength has always been its unchangeable, trustless nature. + +However, this strength came with a trade-off: simplicity. To ensure maximum security and decentralization, Bitcoin was designed with very limited functionality. You can send it, receive it, and hold it, but building complex applications directly on its base layer has been notoriously difficult. + +Bitcoin Season 2 is the collective effort to change that. It’s about building new capabilities on top of and around Bitcoin, enabling it to do more without compromising the core principles that make it valuable. This includes: + +* **Enhanced Scalability:** Making transactions faster and cheaper to support a global user base. +* **Programmability:** Introducing smart contract-like capabilities for more complex financial agreements. +* **Decentralized Finance (DeFi):** Building systems for lending, borrowing, and trading that are native to the Bitcoin ecosystem. +* **Native Asset Creation:** The ability to issue new, unique digital assets directly on the Bitcoin network, a concept being explored with protocols like Runes. + +In essence, Season 2 aims to transform Bitcoin from a passive store of value into an active, programmable base layer for a new financial system. + +## The Magic Wand: Trustless Bridging and Its Immense Power + +When asked what single feature she would grant Bitcoin with a magic wand, Isabel’s answer was immediate and profound: “trustless bridging.” + +To understand this, we first need to break down the terms. + +* **Bridging:** In the crypto world, a crypto bridge is a connection that allows assets or data to move from one blockchain network to another. Think of it as a digital corridor. For example, a bridge could allow you to move your Bitcoin from its native network to another blockchain like Ethereum to use in its DeFi applications. +* **Trustless:** This is the cornerstone of Bitcoin’s philosophy. A trustless system means you don’t have to rely on a third party—like a bank, a government, or a corporation—to validate or secure your transactions. The system works based on cryptographic proof and consensus among network participants. You are in full control. + +Combining these, **trustless bridging** is the ability to connect Bitcoin to other computational systems without introducing a trusted intermediary. “One of the most important properties of Bitcoin, one of the things that makes it hard money, is the fact that it is trustless,” Isabel emphasizes. “So if you could use Bitcoin, not just as a money, but as a base asset that can trustlessly plug into any financial system, that would be, in my opinion, kind of the end of the road for this asset.” + +Why is this so critical? Because right now, most methods for “bridging” Bitcoin involve some level of trust. You might have to lock your Bitcoin with a custodian who then issues you a “wrapped” version of Bitcoin (like wBTC) on another chain. This works, but it reintroduces a central point of failure and a counterparty you must trust—the very thing Bitcoin was designed to eliminate. + +A truly trustless bridge would allow the Bitcoin network itself to verify and secure these connections, enabling your BTC to interact with other systems while remaining under your full, sovereign control. This would unlock the immense security and liquidity of the Bitcoin network for a vast array of new applications across the entire digital economy. + +## Why Do People Call Bitcoin “Dumb”? (And How to Upgrade It) + +The term “dumb” is often used to describe Bitcoin, not as an insult, but as a technical descriptor of its limited functionality. As Isabel explains, this comes down to two main factors: + +1. **It’s an Insular Network:** Bitcoin is fundamentally self-contained. Its protocol is designed to do one thing exceptionally well: maintain its own ledger of transactions. It cannot “see” or verify data from the outside world on its own. This is why a trustless crypto bridge is such a complex challenge—it requires finding a way for this insular network to securely interact with external information. +2. **A Limited Scripting Language:** Every blockchain has a “scripting language” that defines the rules for transactions and enables more complex operations. Think of it as the set of commands the network understands. Ethereum’s language, Solidity, is “Turing-complete,” meaning it can be used to write almost any program imaginable, leading to a rich ecosystem of smart contracts and dApps. Bitcoin’s scripting language, Script, is intentionally far more limited. “Bitcoin literally can’t even do multiplication,” Isabel notes. “Bitcoin can only do very, very, very specific functions… chosen very narrowly, in order to make it function as a monetary network, but basically nothing else.” + +This “dumbness” is a feature, not a bug. The simplicity of Bitcoin’s design is what makes it so incredibly robust and secure. Fewer moving parts mean fewer potential attack vectors. However, to enable Bitcoin Season 2, this functionality needs to be carefully expanded. + +This is where concepts like **Bitcoin Improvement Proposals (BIPs)** come in. A BIP is a formal proposal to change the Bitcoin protocol. One such proposal, mentioned by Nathan, is OP\_CAT. This proposal would reintroduce a simple command (or “opcode”) that was present in Bitcoin’s earliest days, which would allow for the concatenation (linking together) of data. + +StarkWare CEO Eli Ben-Sasson’s analogy for this is perfect: it’s like installing another button on a calculator. It’s a small, simple change, but it dramatically expands the types of calculations you can perform. Activating OP\_CAT could open the door to building more sophisticated logic directly on Bitcoin, paving the way for things like decentralized financial vaults and more secure layer 2 solutions. A layer 2 is a secondary framework built on top of a main blockchain (the Layer 1, like Bitcoin) to improve its scalability and efficiency. By handling transactions off the main chain, a layer 2 can offer faster speeds and lower costs, which is crucial for building the advanced applications envisioned in Season 2. + +## The Killer App of Season 2: Decentralized Lending + +If Bitcoin Season 2 needs a “killer app” to showcase its potential, it will almost certainly be lending. Lending and borrowing are the bedrock of any modern financial system. Today, we have trustless payments with Bitcoin, but we don’t yet have truly trustless lending. + +“I would argue that that is the second most important and second most used use case in the real world other than making payments themselves,” Isabel states. + +So, what would this look like in practice? Imagine you own Bitcoin but need cash for a down payment on a house or to start a business. In the traditional world, you might have to sell your Bitcoin, creating a taxable event and forcing you to give up your position in the asset. + +In Bitcoin Season 2, you could engage in trustless lending: + +1. **Provide Collateral:** You would lock your Bitcoin in a specialized digital contract as collateral for a loan. Crucially, with emerging technologies like Discreet Log Contracts (DLCs), you could do this while retaining self-custody of your Bitcoin. This means you still hold the private keys, and no one can move your BTC without your permission. +2. **Receive a Loan:** In return, you would receive a loan, perhaps in a stablecoin (a cryptocurrency pegged to a stable asset like the US dollar). +3. **Repay the Loan:** You make your loan payments according to the agreed-upon schedule. As long as you make your payments, your Bitcoin remains securely yours. +4. **The Failsafe:** Only if you default on the loan can the lender verifiably and automatically claim the collateral. This entire process is governed by mathematical proof, not by the trust or goodwill of a bank or lending company. “That’s proven by math rather than trust,” says Isabel. “That is the key thing.” + +This single application would be revolutionary. It would allow Bitcoin holders to unlock the liquidity of their assets without selling them, all within a completely decentralized and permissionless framework. + +## A New Financial Reality for a Global Audience + +The implications of these developments extend far beyond the existing crypto community. As Gareth passionately illustrates, they have the power to create a more equitable and accessible global financial system. + +He paints a vivid picture: consider someone living in a country grappling with hyperinflation, where the local currency loses its value daily. Their life savings are evaporating. + +* **Step 1: Acquire Sound Money.** This person needs a way to preserve their wealth. With just an internet connection and a smartphone, they can set up a Bitcoin wallet and acquire some Bitcoin, instantly opting into a global, censorship-resistant monetary system. They don’t need a bank account, a passport, or anyone’s permission. +* **Step 2: Build Wealth.** Over time, they accumulate a significant amount of Bitcoin. They have successfully protected their family’s wealth from hyperinflation. Now, they want to buy a house, but they are locked out of the traditional banking system. +* **Step 3: Access Capital.** This is where Bitcoin Season 2 comes in. Using the decentralized lending functionality we just described, this individual can take out a loan against their Bitcoin. As Gareth explains, “I stake my Bitcoin or deposit my Bitcoin, I still control the keys, so I’m technically in control of it. I receive the capital that I need.” +* **Step 4: Achieve a Dream.** They receive a stablecoin loan, which they can use to buy the house. They can then begin paying off the loan over time, all while their primary asset—the Bitcoin collateral—remains securely in their custody. + +“I haven’t had to involve a bank or a third party at any point of this,” Gareth concludes. “And I’ve used a completely peer-to-peer decentralized network and didn’t have to ask for permission from anyone. That’s the kind of future that we are moving towards… a few little changes to some lines of code might just unlock that for all of us.” + +This is the ultimate promise of Bitcoin Season 2: to provide the tools of financial sovereignty to anyone, anywhere in the world, transforming Bitcoin from a simple asset into a foundation for empowerment and opportunity. + +As we look ahead, the conversation is shifting. The stories of tomorrow will be less about price and more about utility, focusing on real-world asset tokenization, decentralized identity, and a host of other applications built on the unshakable foundation of Bitcoin. The journey from a “dumb” network to a world computer is well underway, and as this episode makes clear, the future it unlocks could be more profound than any of us can yet imagine. + +--- +Sources: + - https://www.starknet.io/blog/product-market-fit/ +--- + +## Starknet's Product-Market Fit: Explained | Starknet + +Home  /  Blog + +A deep dive into how Starknet achieves scale, superior UX, and long-term vision + +Written by: Lyskey + +Aug 5, 2025 · + 16 min read + +### **TL;DR** + +* Starknet has achieved true Product-Market Fit by solving crypto’s core problems. +* It offers massive scale and low fees without sacrificing security or decentralization. +* Native Account Abstraction delivers a seamless Web2-grade UX with Web3 guarantees. +* Its custom-built stack (Cairo) is designed for long-term superiority and innovation. +* The ecosystem is attracting top-tier builders with growing developer retention rates. + +In the chaotic and often ephemeral world of cryptocurrency, the term “Product-Market Fit” (PMF) has been co-opted, diluted, and frequently misused. It’s become a hollow buzzword, loosely applied to fleeting hype cycles and speculative rallies rather than signifying a true, sustainable connection between a product and a market need. But what happens if we reclaim the term and apply its original, rigorous definition? What if we treat PMF not as a meme, but as the critical milestone it represents: the precise moment a product definitively solves a real, painful problem for a clearly defined audience, better than any available alternative? + +When viewed through this serious lens, a clear picture emerges. After years of deep, foundational research and development, building from first principles while others took shortcuts, Starknet is finally and undeniably finding its Product-Market Fit. This isn’t a story about a short-term pump or a clever marketing campaign. It’s the story of a technology patiently and methodically engineered to solve the most difficult, persistent problems in the blockchain space: the trade-offs between scale, security, and user experience. + +This article will break down, in detail, exactly how Starknet is achieving this. We will explore the market’s deepest needs, the product’s core value proposition, the radical feature set that underpins it, and the unparalleled user experience that results. The goal is to understand what truly sets Starknet apart and how it delivers on the holy grail of crypto: scale without compromise. + +Starknet’s PMF in high-level (I’ll break it down to pieces in the next chapters) : + +* **Solving the Unsolvable Trilemma:** Starknet is engineered to deliver massive computational scale, enabling thousands of transactions per second with vanishingly low fees. Crucially, it achieves this without sacrificing the non-negotiable pillars of blockchain: cryptographic security and credible decentralization, a feat that has eluded most other blockchains. +* **Web2 Experience with Unyielding Web3 Principles:** Starknet provides a user experience that feels as intuitive and seamless as the best Web2 applications. This is made possible by native Account Abstraction, a design choice made at genesis that elegantly eliminates the friction points plaguing crypto adoption—gas fees, confusing pop-ups, and the anxiety of seed phrases—all while preserving true self-custody and user ownership. +* **Built Different, Therefore Built to Last:** Starknet’s power stems from a courageous, long-term decision to build its technology stack from scratch. Instead of adopting the familiar but limited EVM, Starknet is built on Cairo development language, a custom VM designed specifically for ZK-proofs and provable computation. This difficult path has laid the groundwork for a future of compounding technological superiority that is now becoming evident. +* **A Haven for Serious Builders:** In a digital landscape littered with the ghosts of short-term, extractive projects, Starknet stands out as an ecosystem built for resilience and long-term innovation. It attracts and retains builders who are weary of hype cycles and are committed to creating sustainable, meaningful applications on a platform with a multi-cycle vision and a track record of shaping the future of the industry. + +### + +## **Part I: Defining the Market — Who Are We Building For?** + +Before any product can find its fit, it must have a crystal-clear understanding of its market. For a public L2 like Starknet, the market is twofold: the developers who build on the layer, and the end-users they attract. + +#### + +### **The Primary Customer: The Developer** + +Public blockchains are ultimate platforms; their potential is defined by what can be built upon them. Therefore, developers are the primary customers, the core leverage point of the ecosystem. They are the builders of protocols, applications, and games that bring in and serve millions of end-users.. Starknet’s architecture and vision resonate with three distinct but overlapping archetypes of developers. + +1. **The Crypto-Native Builder, Unchained from the EVM** + +This is the developer who lives and breathes crypto. They have built on the EVM, they understand its nuances, but they are profoundly frustrated by its inherent limitations. They feel creatively and technically capped by the EVM’s computational boundaries and rigid design. These builders are driven to create applications that are simply not feasible on legacy infrastructure: fully onchain games with complex logic, consumer apps with embedded web3 features, high-frequency DeFi protocols, and AI applications that require massive onchain computation. They are not looking for incremental improvements; they are searching for a new paradigm. This market of highly active, open-source crypto developers numbers between 20,000 and 30,000, a small but incredibly influential group that pioneers new possibilities. Even if the true number is likely 2-3x higher, it remains a tiny fraction of the global developer pool, highlighting the need for platforms that can appeal beyond this core group. + +2. **The UX-First Visionary** + +This developer’s obsession is the end-user experience. They believe—correctly—that mainstream adoption of web3 is fundamentally blocked by terrible UX. The current state of crypto, with its confusing wallets, intimidating seed phrases, and unpredictable gas fees, is a non-starter for the average person. These builders are on a mission to deliver fast, seamless, and abstracted interactions that feel as effortless as using a Web2 app, but they refuse to compromise on the core tenets of decentralization and user ownership. They are actively seeking better primitives and a platform where a frictionless experience is the default, not a difficult hack. + +3. **The Pragmatic Web2 Developer** + +This represents the largest potential market by far: the 25-30 million developers globally who currently build in the Web2 world. They are not crypto ideologues, but they are curious and increasingly recognize the unique value propositions of web3. They are interested in giving their users true self-custody over their data and assets, enabling composability with the burgeoning world of DeFi, and exploring native monetization models. However, they will only make the leap if they can do so without subjecting their users to the hostile UX of traditional crypto. This market is over 300 times the size of the current crypto-native builder base, and capturing even a small fraction of it requires a platform that speaks their language: performance, reliability, and and complexity abstraction. + +While Starknet’s initial focus was on the crypto-native builders, its long-term strategy is increasingly geared towards empowering the UX-first and Web2 developers who will onboard the next billion users. + +#### + +### **The Secondary Customer: The End User** + +Developers build, and users come for what they’ve built. The applications flourishing on Starknet indicate a strong appeal to several key user segments: + +* **Gamers:** The holy grail of blockchain gaming is the “fully onchain game,” where not just the assets, but the entire game logic, state, and strategy exist on a decentralized, permissionless, and self-custodial ledger. Starknet’s performance, low fees, and dedicated tooling (like the Dojo engine) are making this dream a reality, attracting gamers who want persistent, community-owned worlds that cannot be shut down by a central server. +* **DeFi Users:** This group ranges from sophisticated traders to passive yield seekers. They are drawn to Starknet by the promise of more efficient trading experiences (like those on AMMs such as Ekubo), better yield opportunities through innovative protocols, and advanced use cases that require computational power beyond the EVM’s reach. +* **Consumer App Users:** This is the mainstream audience that has been historically unreachable for crypto. They are onboarded through applications with a true Web2-like feel, where the blockchain is entirely invisible. They are often mobile-first, demand low-friction experiences, and have no patience for seed phrases, transaction popups, or network switching. The current generation of blockchain infrastructure serves them poorly, which is precisely the gap Starknet was built to fill. + +### + +### **The Underserved Needs: What the Market is Missing** + +Across all these developer and user segments, a consistent set of deep, unaddressed pain points emerges. The market is failing to deliver on three fundamental promises. + +1. **Scalability Without Compromise** + +The entire blockchain industry has been locked in a frustrating trade-off. On one side, you have high-performance chains that achieve incredible speed and low latency, but often do so by pushing decentralization and security into the background, operating more like centralized servers than true blockchains. On the other side, you have the credibly decentralized and secure titans, Bitcoin and Ethereum, which are painfully slow and expensive to use, providing a poor user experience. + +The market is desperately missing a solution that offers the complete package: + +* High throughput and low latency. +* Low, stable, and predictable transaction fees. +* Unyielding, mathematically-guaranteed security and credible decentralization. + +A legitimate question arises here: why should anyone care about decentralization today, when the market seems to reward speed above all else? The answer is simple. A fast and cheap network is good, but without decentralization and security, it’s ultimately meaningless. A blockchain is supposed to be a trustless coordination engine, not just a database. If you strip away its core properties, you are left with something that is just a slow, clumsy, and inefficient database—a job for which centralized systems are far better suited. + +Sacrificing decentralization is a dangerous short-term bet. It follows the logic of the “Thanksgiving Turkey,” who believes everything is going great for 1000 days, right up until the surprising and catastrophic 1001st day. The crypto landscape is a graveyard of centralized actors—Mt. Gox, Celsius, FTX—that worked perfectly until, suddenly, they didn’t. Sooner or later, a centralized or insecure onchain service will suffer the same fate. In the centralized world, everything works until it breaks, and when it breaks, you lose everything. + +2. **Web2-Grade UX with Web3 Guarantees** + +For the vast majority of potential users, crypto UX today is an absolute nightmare. The experience is fraught with friction and anxiety: + +* The stress of managing and securing seed phrases. +* The constant interruption of transaction signing popups. +* The confusion of unpredictable and often exorbitant gas fees. +* The complexity of implementing advanced security measures on wallets. +* The generally poor and limited support for mobile-native experiences. + +Even for developers, building a good user experience is an uphill battle. On most chains, they must build their own Account Abstraction infrastructure, deal with the friction between new smart accounts and legacy EOA wallets, and waste precious time explaining UX flows that should simply be invisible. There is a colossal gap between the seamless experience the market wants and what is actually possible out-of-the-box on most platforms. + +3. **Long-Term, Credible Ecosystems** + +Much of the crypto market operates on short-term, extractive cycles. Protocols launch with a bang, attract liquidity with unsustainable incentives, and then fade into obscurity as attention moves elsewhere. Ecosystems chase fleeting narratives and marketing hype instead of focusing on fundamental technological innovation. For builders, this creates a deeply unstable environment. They have no guarantee that the platform they invest their time and resources in will continue to support them or even exist through multiple market cycles. + +There is a profound need for ecosystems that are: + +* Actively innovating on core infrastructure, not just marketing. +* Led by teams with a proven, multi-cycle track record and a long-term vision. +* Deeply committed to the principles of decentralization and open-source technology. + +In summary, the market’s needs are clear. Developers want an execution environment that breaks free from the EVM’s constraints, unlocking new application paradigms and removing user friction. Users want faster, simpler, and more intuitive experiences without relinquishing the powerful guarantees of trustlessness and ownership. And everyone involved wants to build on and use an ecosystem that is designed to last, not one that will chase the next hype cycle before collapsing. + +So, how does Starknet respond to these profound, unmet needs? Let’s move to the product itself. + +## **Part II: The Product — Starknet’s Answer to the Market** + +#### + +### + +### **The Value Proposition: What Starknet Promises** + +Starknet’s core promise is both simple and audacious: it is a blockchain that scales without sacrificing decentralization or security, all while offering a world-class, Web2-grade user experience to everyone. It provides a fundamentally different blockchain experience, one that holistically combines performance, user-friendliness, security, and long-term integrity into a single, cohesive architecture, without compromise. + +Here’s how it delivers on this promise: + +1. **Scalability Without Sacrifice:** High TPS, low latency, and ultra-cheap fees are not just theoretical goals on a roadmap; they are live today and continuously improving. All this performance is achieved without compromising on the path to full, credible decentralization and Ethereum-grade security. +2. **Best-in-Class User Experience:** Thanks to having native Account Abstraction as the standard from its very first block, Starknet empowers builders to completely abstract away the blockchain’s complexity. This enables a universe of Web2-like interactions: gasless transactions, invisible wallets created via social logins, multi-factor authentication, and the elimination of endless transaction popups . dApps on Starknet can look and feel like the slickest Web2 services while remaining fully onchain and self-custodial. +3. **Long-Term Alignment and Vision:** In an industry flooded with short-term plays, Starknet is engineered for resilience and multi-cycle relevance. Its primary contributor, StarkWare, has a long history of pushing innovations that were initially ignored or dismissed by the market—from STARKs to Validiums to altVMs—only for them to later become industry standards. Builders who choose Starknet are aligning with a technology stack and a vision that has already shaped crypto’s past and is poised to define its future. + +In short, Starknet delivers the raw performance that developers need, the seamless UX that users expect, and the trustless integrity that blockchains promise, all within one unified architecture. + +### **The Feature Set: How Starknet Delivers** + +The reason Starknet can deliver on such an ambitious value proposition is simple, but radical: it wasn’t built by assembling existing, off-the-shelf parts. It was painstakingly built from scratch. + +Where most competitors took the “easy path”—reusing the EVM and making minimal changes to existing stacks to get to market faster—StarkWare took the “hard path”. They invested the time, effort, and resources to build a new layer from first principles: a new virtual machine (Cairo), a new proving system, and an entirely new philosophy for blockchain UX. This difficult, long-term choice laid a foundation for compounding technological superiority. Now that this foundation is mature, the technological gap between Starknet and its competitors is set to widen dramatically. + +Let’s break down how this unique design delivers real, tangible advantages across four critical dimensions. + +1. **A Deep Dive into Scalability Primitives** + +At the heart of Starknet’s performance is the + +**CairoVM**, a custom-built virtual machine designed specifically for ZK-proofs and scalable, provable computation. Unlike the EVM, which was not created with ZK-proofs in mind, Cairo is a high-performance, Turing-complete VM optimized for them from day one. Put simply, Cairo enables patterns of execution and computational complexity that are simply impossible or prohibitively expensive on the EVM. This unlocks a whole new class of applications, particularly those requiring heavy onchain computation, like sophisticated onchain games and AI models. + +This superior architecture has led to staggering performance gains: + +* **Speed:** Just last year, the average transaction speed on Starknet was around 15 seconds. Today, it consistently sits between 1-2 seconds, and the core team has a clear roadmap to bring that below 1 second. This is part of our roadmap: In reality, with Starknet v0.14 dropping in a few weeks, most transactions will complete in just 500ms, thanks to the new pre-compile feature. +* **TPS Capacity:** Starknet can currently support a throughput of around 1,000 TPS. With a clear plan for further optimization, this can be increased to 10,000 TPS and beyond as soon as network demand makes it the bottleneck. +* **Gas Fees:** Starknet is already one of the cheapest L2s for users. What’s truly remarkable about its design is the fee dynamic: the more the network is used, the cheaper it gets for each individual user (as long as TPS capacity isn’t saturated). This is the polar opposite of most blockchains, which see fees skyrocket with increased activity. + +This trend is undeniable: TPS is going up, and fees are going down. And the performance is set to improve even more with several major upcoming upgrades: + +* **Cairo Native:** An upgrade that will improve sequencer performance by an estimated 3-5x. +* **Mempool / Fee Market:** This will allow users who need faster inclusion to compete for priority execution, creating a more dynamic fee market. +* **S-two (Next-Gen Prover):** An open-source prover that is a staggering 1,000x faster than the current one, enabling cheaper and faster STARK proofs and unlocking new capabilities like client-side proving. + +This scalability is not confined to a single layer. With the **SN Stack**, Starknet’s open-source appchain offering, builders can deploy their own custom Starknet chains, optimized for their specific needs. By building with the SN Stack, developers gain access to the most battle-tested ZK stack in the industry, a resource-efficient architecture, Web2-grade UX through native AA, and seamless interoperability between L1, L2, and L3 layers. This offers a full spectrum of scaling options, from maximum composability on the shared L2 to ultimate control and hyperscaling on dedicated L2/L3s appchains. + +2. **A Deep Dive into Security & Decentralization** + +Security without compromise is embedded in Starknet’s DNA. It is designed not just to scale, but to scale safely in alignment with the trust guarantees of its settlement layer, Ethereum (and hopefully in the future, Bitcoin). + +* **STARK Proofs:** Starknet is secured by STARKs, the most secure and quantum-resistant cryptographic proof system available today. Battle-tested on StarkEx since 2020 and on Starknet since 2021, STARKs have already processed over 1 billion transactions and secured over $1.3 trillion in trading volume. +* **No Trusted Setup:** A critical and often overlooked advantage of STARKs is that they do not require a trusted setup ceremony. This eliminates a significant trust assumption and potential vector for compromise, making Starknet the only major Validity/ZK-Rollup in production without this vulnerability. + +* **A Clear Path to Full Decentralization:** Starknet is recognized by the independent auditor L2Beat as a Stage 1 Rollup, with active work already underway to reach Stage 2, at which point the network will be fully trustless with complete escape guarantees for users. In addition, the ecosystem is committed to open-sourcing all its core components, including the upcoming S-two prover and Apollo sequencer, and already boasts the most decentralized stack of any L2 by a wide margin. + +* **Decentralizing Without Losing Performance:** Starknet is in the midst of a transition to a decentralized network secured by Proof-of-Stake consensus. This will be powered by STRK staking and, in a novel addition, BTC staking, creating a dual-token security mechanism. Normally, decentralizing a sequencer network introduces latency and slows a network down, as coordination between multiple validators is inherently slower than a single operator. However, Starknet will bypass this trade-off thanks to + **Malachite**, a high-performance consensus engine built by Informal Systems. Tests show Malachite can handle ~50k TPS with a latency of just ~780ms across 100 validators. This means that when Starknet transitions to a decentralized sequencer set, it will become more robust and decentralized while *still* maintaining its high performance. Starknet is the real answer to the blockchain trilemma. + +3. **A Deep Dive into Blockchain Complexity Abstraction** + +Starknet provides the best user experience in the market, and there is no close second. The foundation for this is **native Account Abstraction (AA)**. While Ethereum is only now beginning to integrate AA, it has been the native, universal standard on Starknet since 2021. This makes a world of difference. On EVM chains, developers must support two different account types (legacy EOAs and new smart accounts), creating a fragmented and inconsistent experience. On Starknet, all accounts are smart contracts, meaning all tooling, infrastructure, and dApps contribute to a single, unified, and continuously improving UX. + +This native AA unlocks a suite of powerful features for users: + +* **1-Click Everything:** Users can approve, swap, provide liquidity, and stake all in a single transaction, turning complex DeFi operations into a one-click flow. +* **Session Keys:** Users can grant specific, limited permissions to a dApp for a set period or spending cap. This means you can sign in to a game once and then play for hours or days without any further transaction popups, enabling a truly fluid and uninterrupted experience. + +* **Paymasters:** This powerful primitive unlocks two key use cases. First, users can pay gas fees in over 10 different tokens, not just ETH or STRK. Second, applications can choose to sponsor gas fees for their users, completely abstracting away the cost of infrastructure, just like Web2 platforms do. The result is a radically smoother and more flexible UX with zero friction at the gas layer. +* **Invisible Wallets:** These services bundle Paymasters, Session Keys, and social logins into a single, seamless onboarding interface. Users can log in with their Google or Discord account and start using an app immediately, without ever needing to think about gas tokens, wallet setup, or transaction popups. +* **Multifactor Authentication (2FA/3FA):** Wallets like Argent and Braavos offer users the ability to add extra layers of security to their accounts. With it, even if a user’s private key is compromised, funds cannot be moved without their confirmation from a second device, providing bank-level security with full self-custody. + +Because these primitives are native and composable, the Starknet UX stack is constantly compounding. Wallet providers innovate on onboarding flows, and developers can rely on a standardized toolkit instead of building everything from scratch. This is how the consumer app Focus Tree was able to onboard nearly 300,000 blockchain novices in just three weeks for a cost of only $1,100. Starknet hides the blockchain without removing what makes it matter: Web3 benefits with a Web2 UX. + +4. **A Deep Dive into the Long-Term Focused Ecosystem** + +For builders who want to create lasting value, choosing an ecosystem is one of the most critical decisions they will make. The crypto landscape is treacherous, filled with projects focused on short-term extraction and ecosystems that were never designed to last beyond a single bull run. + +Starknet offers a clear alternative. Its main contributor, StarkWare, has been shipping breakthrough innovations for over seven years. Many of these innovations were initially doubted or ignored by the wider market, only to later become industry standards adopted by competitors. Consider the track record: + +* **STARK proofs (2018):** Once dismissed as too complex, now recognized as the leading proof system for security and scalability. +* **Validium (2019):** A data-off-chain scaling solution now being adopted by major projects. +* **Proof Aggregation (2020):** A technique for combining many proofs into one, now being rebranded and used by competitors like Polygon and zkSync. +* **The first general-purpose Validity Rollup (2021)** and the **first non-EVM, general-purpose L2** with Starknet +* **The first L2 fully based on Account Abstraction (2021)**. + +The decisions StarkWare made years ago are being validated by the market one by one. The vision for alternative VMs to achieve faster execution is now being endorsed by Vitalik Buterin for Ethereum L1, and Account Abstraction is finally coming here on Ethereum with the Pectra upgrade. The next bold step is already underway: making Starknet a Layer 2 for both Ethereum and Bitcoin, a vision StarkWare’s founder, Eli Ben-Sasson, has had since 2013. If history is any guide, the choices Starknet is making today will become the standards of tomorrow. + +### **Conclusion: The Moment of Truth** + +Starknet has undeniably played the long game. It chose the hard path of building from scratch, refusing to take shortcuts or compromise on its core values of security and decentralization. For a time, this meant a slower path to market. But now, that foundational work is bearing fruit, and the Product-Market Fit is undeniable. + +The Starknet stack is now production-ready for mass scaling and is open to everyone. It delivers the best and most consistent UX in crypto, and it’s not even close. As a result, top-tier teams are choosing Starknet to build the future. + +We see this in DeFi with: + +**Ekubo**, the most efficient AMM in the space, and **AVNU**, the best DEX aggregator. We see it in gaming with **Dojo** and **Cartridge**, the premier infrastructure for fully onchain games like **Eternum** and **Influence** that require massive onchain computation. We see it in consumer apps like + +**Focus Tree**, which onboarded hundreds of thousands of web2 users with ease. And we see it in the next generation of appchains like the perpetuals DEX **Paradex**. + +If you need more proof, look at the developers. While global web3 developer metrics have been in a steady decline since their 2022 peak, developer activity on Starknet is moving in the exact opposite direction. The number of Cairo developers continues to grow, and Starknet’s developer retention rate is among the best in the entire industry. + +The evidence is overwhelming. If you want to build an application like Hyperliquid, an onchain version of Civilization, or an AI-native app that needs massive compute, you can do it all on Starknet—with a better user experience, true self-custody, and security and decentralization by design. + +So let’s be real: If you’re building in crypto today and you’re not seriously looking at Starknet, you are probably building on the wrong stack. The long period of foundational building is over. The moment of truth has arrived. When you’re ready to build for the future, the Starknet ecosystem will be here, ready to welcome you and help you create what comes next. + +See you on the STARK side. + +--- +Sources: + - https://www.starknet.io/blog/ekubo-the-amm-endgame/ +--- + +## Ekubo: The AMM Endgame | Starknet + +Home  /  Blog + +The decentralized exchange market is plagued by inefficient designs and tokens that fail to capture value for their holders. This deep dive breaks down how Ekubo, engineered by a core architect of Uniswap v3 and v4, solves these fundamental problems to create the ultimate liquidity layer for all of trading. + +Written by: Lyskey + +Aug 14, 2025 · 43 min read + +### The ultimate Liquidity Layer for all things trading: how Ekubo rewrites the AMM playbook + +In the dynamic and ever-evolving landscape of cryptocurrency, trading has consistently remained the cornerstone use case. This fundamental truth has not wavered. Even with the exciting emergence of novel concepts such as Decentralized Physical Infrastructure Networks (DePIN), Artificial Intelligence (AI), or blockchain-based gaming, the vast majority of transaction volume, generated fees, and overall user engagement is anchored to a single, pivotal activity: trading. However, a significant disconnect has become apparent. While trading continues to reign supreme, a large number of Decentralized Exchanges (DEXs) have failed to progress beyond rudimentary, short-term incentive programs, architecturally inefficient designs, and native tokens that struggle to capture any meaningful portion of the value they help create. Ekubo is engineered to change this paradigm, and we are proud to witness this significant evolutionary step taking place on Starknet, leveraging its own set of groundbreaking technologies. + +Ekubo represents a protocol that has been entirely bootstrapped from its inception, a conscious decision made to avoid venture capital funding, reject any developmental shortcuts, and maintain an unwavering, laser-like focus on building a superior product. The result is a best-in-class infrastructure layer meticulously designed for the world of trading, which masterfully combines several critical elements: + +* **Ultra-concentrated liquidity:** A mechanism that allows for unprecedented capital efficiency. +* **Gas-optimized execution:** An architecture that significantly reduces transaction costs for all users and liquidity providers. +* **Permissionless extensions:** A framework that empowers developers to build novel applications directly on top of the core protocol. +* **Tokenomics that actually align with usage:** A model where the protocol’s success directly translates into value for token holders. + +The true power of this model becomes evident when considering its composability. Because Ekubo’s extensions are entirely permissionless and integrate directly with Ekubo’s foundational liquidity layer—which is arguably the most efficient and sophisticated in the entire DeFi space—developers can launch virtually any DeFi primitive directly on top of it. This approach offers a superior user and developer experience, much tighter and more seamless integration, and vastly improved capital efficiency compared to launching a new standalone protocol or building on a legacy Automated Market Maker (AMM). Whether the application is a Dollar-Cost Averaging (DCA) tool, a token launchpad, a suite of advanced order types, or even complex derivatives like options, if it has a trading component, it can be constructed more effectively and efficiently on Ekubo. + +Furthermore, Ekubo is not an exclusive platform for developers. Far from it. Whether you identify as a high-frequency trader, a diligent gem hunter seeking the next big opportunity, a liquidity provider (LP) aiming to maximize returns, or a protocol developer looking for a robust foundation, Ekubo provides DeFi’s most powerful and versatile liquidity engine. It is a system built with perfectly aligned incentives that benefit all stakeholders across the ecosystem. + +This analysis will focus on explaining the how and why behind Ekubo’s innovative approach, structured into the following comprehensive sections: + +> I. Context +> +> II. Market Problems +> +> III. Solution +> +> IV. Ekubo features +> +> V. Team and backers +> +> VI. Metrics +> +> VII. How Ekubo Can Grow +> +> VIII. Tokenomics +> +> IX. Risks + +*Before we start, note that this article reflects only the views of its author,* *Lyskey**. It is provided for informational purposes only and explains how Ekubo differentiates itself from other DEXs. It is not meant to provide any financial advice. Please always stay SAFU, verify information, and DYOR.* + +### I. Context + +This article is already quite detailed, and it’s likely that most readers do not require a comprehensive refresher on the inner workings of Automated Market Makers. To avoid bloating this document with fundamental concepts, I have moved the key ideas into a separate, standalone companion piece. There, I cover the essential concepts that underpin Ekubo’s design, including: + +* What’s an AMM +* Slippage +* Impermanent Loss +* Differences between AMM v1, v2, v3, v4 + +If you would like a high-level refresher to better grasp why Ekubo represents such a significant leap forward, please start here. + +For all the seasoned AMM OGs out there, let’s jump straight into the specifics of Ekubo. + +### II. The Market Problems + +The architecture of AMMs has certainly matured, with the v4 model being specifically engineered to address two fundamental challenges of its predecessors: first, to dramatically reduce costs for both liquidity providers and traders by implementing a more efficient architectural framework, and second, to facilitate permissionless extensions (or “hooks”), which allows any conceivable DeFi primitive to be constructed directly upon a simple AMM pool’s foundation. + +However, technological advancement by itself is not the primary impediment to progress; the structure of the market itself presents a more formidable obstacle. The decentralized exchange landscape is heavily dominated by Uniswap and its most successful fork, PancakeSwap. Together, they consistently command the lion’s share of trading volume and Total Value Locked (TVL) on EVM-compatible chains, frequently accounting for 65-70% of the total market on any given day. While new and innovative projects occasionally emerge (such as the recently launched Fluid), none have yet managed to make a significant and lasting dent in the powerful network effects that Uniswap has cultivated over the years. When a single project is the primary driver of most significant upgrades and optimizations in the AMM space, the overall pace of innovation becomes constrained, tethered to the timeline and priorities of a single entity’s roadmap. This has led to a discernible lack of groundbreaking innovation originating from projects outside the immediate Uniswap ecosystem. + +Compounding this issue, the token design implemented by most leading AMMs remains fundamentally weak and fails to capture the value generated by the protocol. The prime example is UNI, the native token of Uniswap. It offers no direct revenue sharing mechanism for token holders, no buyback-and-burn program, and no other direct means of value accrual. As is the case with the majority of AMM tokens, its utility is largely confined to governance, and it captures little to no economic value from the protocol’s operations. The fees generated from billions of dollars in daily volume primarily flow to liquidity providers and the protocol’s treasury, which is controlled by the team and major investors, not to the token holders who are meant to be the owners of the protocol. + +Furthermore, the initial fundraising and token distribution for many of these projects were heavily weighted towards insiders. Venture capital firms were able to invest at extremely deep discounts during early seed and strategic rounds, long before the tokens were made available to the public on the open market. The potential for massive upside, therefore, was largely extracted before retail participants even had a chance to get involved. + +The consequence of this market structure and token design is stark and undeniable: there is a progressively widening chasm between the growth and success of the protocol and the financial returns experienced by its token holders. + +Ekubo is strategically and technologically positioned to rectify these deep-seated issues. + +## III. Solution + +Ekubo is a Decentralized Exchange (DEX) that has been meticulously constructed with a product-first philosophy. This approach is anchored by two fundamental, non-negotiable core principles: first, to deliver the most efficient, robust, and powerful liquidity layer for all trading activities, and second, to ensure that the growth and success of the protocol are inextricably and directly linked to the value accrued by its token holders. + +Its underlying architecture is engineered for peak performance at every conceivable level. Ekubo relentlessly pushes the boundaries of capital efficiency to their absolute limits by implementing a combination of ultra-concentrated liquidity, a highly efficient singleton contract system, and an innovative till-based execution model. This synergistic combination works to minimize redundant token transfers and drastically reduce gas consumption for every on-chain action. + +Beyond its sophisticated architecture, Ekubo provides an unparalleled degree of flexibility for both liquidity providers and developers. Through the implementation of permissionless extensions, any individual or team can build and seamlessly integrate custom on-chain strategies. They can even go so far as to create entirely new types of pool logic, all natively within the core protocol’s framework. + +This forward-thinking design effectively transforms Ekubo from a simple DEX into a foundational liquidity infrastructure layer for the entirety of the DeFi ecosystem. It is a protocol that is at once highly efficient, endlessly composable, and remarkably adaptable. Every single optimization, from the smallest code refinement to the largest architectural decision, is made with a clear and unwavering set of objectives: to improve trade execution for traders, to maximize the yield earned by LPs, and to guarantee that the economic value created at the protocol level directly accrues to the individuals who hold the EKUBO token. + +This ambitious vision is not merely theoretical; it is backed by profound technical credibility. Moody, the visionary founder of Ekubo, was a core contributor to the development of Uniswap v3. He personally wrote a significant portion of its codebase and went on to lead the architectural design of the subsequent Uniswap v4. Ekubo is built upon this formidable foundation, taking the lessons learned and meticulously refining and extending the design in the areas where it matters most. + +By masterfully combining four foundational pillars, Ekubo establishes a new, higher benchmark for the design and functionality of Automated Market Makers (AMM): + +1. **Gas-efficient architecture,** achieved through the synergistic use of the singleton architecture and the till pattern. +2. **Capital efficiency,** realized via extremely precise tick sizing and the power of liquidity concentration. +3. **Modularity,** enabled by a system of fully permissionless extensions that foster limitless innovation. +4. **Token alignment,** created through a novel system of protocol-level withdrawal fees and DAO-managed buybacks that directly benefit holders. + +Let us now proceed to explore each of these critical components in comprehensive detail. + +## IV. Ekubo main features + +### Singleton + +Ekubo leverages a sophisticated singleton contract architecture, a design that marks a significant departure from traditional AMM implementations. In the conventional model, which encompasses virtually every AMM developed before the conceptualization of Uniswap v4, each individual liquidity pool is deployed as its own distinct and separate smart contract. This approach inevitably leads to the same core logic being duplicated over and over again for every new pool, with the associated gas costs for deployment being paid each and every time. + +Ekubo takes a fundamentally different and more intelligent approach. + +With its singleton architecture, all liquidity pools, regardless of the token pair, exist and are managed within a single, unified smart contract. There is just one core contract for all pools. This is the origin of the term “singleton,” and it is this design choice that unlocks several major benefits: + +* There is absolutely no need to redeploy the shared, common logic every time a new trading pair is introduced. +* The creation of new pools becomes approximately 99% cheaper in terms of gas consumption, removing a significant barrier to entry for new markets. +* Swaps executed on the platform cost roughly 50% less in gas. This saving is achieved through a reduction in storage writes and, crucially, the elimination of token transfers between pools that would otherwise reside in separate contracts. +* The unified structure makes the process of aggregating liquidity and routing trades internally far simpler and more efficient. +* Traders receive better pricing for multi-hop swaps (e.g., trading from Token A to Token C via Token B), as the intermediate steps in the trade route are executed at a much lower cost. + +In essence, the singleton design makes Ekubo a cheaper, faster, and more efficient platform for all its participants: liquidity providers, traders, and developers alike. + +### Till Pattern + +Ekubo implements the “till pattern,” a highly efficient mechanism where the token transfers associated with a user’s actions are not processed incrementally with each individual interaction. Instead, they are intelligently batched together and finalized in a single, consolidated step only at the very end of the entire transaction. + +To make this concept more intuitive, think of it like a trip to the supermarket. You walk through the aisles, grabbing all the items you need—which in the DeFi world could be executing swaps, performing LP actions like adding or removing liquidity, and updating your position ranges. You collect everything in your cart and only pay once at the checkout counter. Ekubo’s till pattern functions in precisely the same way. Rather than triggering an on-chain token transfer after each discrete operation, it defers all token movements until the full sequence of actions is complete. It then calculates the net result and handles all the necessary transfers in a single, highly optimized step. This approach dramatically reduces the operational overhead, eliminates unnecessary and redundant back-and-forth token movements, and significantly lowers the overall gas costs for the user. + +For aggregators, which route a substantial portion of DeFi volume, the benefits of the till pattern are even more pronounced. They can leave tokens within the Ekubo contract throughout a complex series of actions, batching everything into a single, seamless flow, and only executing the final net settlement when absolutely necessary. This greatly improves composability and drives down execution costs, allowing them to offer better prices to their users. + +The till pattern unlocks several key advantages: + +* Fewer token transfers directly translate into cheaper and faster transactions for everyone. +* The flow of capital becomes more efficient, creating a positive feedback loop that benefits LPs, traders, and aggregators. +* Perhaps most significantly from a technical standpoint, Ekubo supports safe reentrancy. While most DeFi protocols strictly restrict nested calls to prevent security vulnerabilities and reentrancy exploits, Ekubo’s design enables secure, modular interactions—even across different contracts—without introducing new attack vectors. + +As a direct result of this, smart contracts can interact with Ekubo with a level of freedom and flexibility that is impossible on other platforms. They are not constrained by rigid, linear transaction logic. Aggregators can chain multiple swaps or liquidity management operations together in a single atomic call, while the actual token transfers are only executed when strictly necessary. This minimizes gas usage and provides a much smoother, more intuitive user experience. + +In short, the philosophy is simple: batch all the logic first, and settle the net result later. That is the power of the till pattern. By combining this innovative pattern with the singleton contract design, Ekubo achieves an ultra-high level of gas efficiency, making it arguably the AMM that delivers the absolute best execution price, net of all gas fees. + +### Ultra-Concentrated Liquidity + +Ekubo takes the revolutionary concept of concentrated liquidity and pushes it to its logical and practical extreme. While many contemporary AMMs offer basic implementations of this feature, Ekubo introduces a level of hyper-precision that is unmatched in the industry. It achieves this through the use of tick sizes that are as small as 1/100th of a basis point, which translates to a price increment of just 0.000001. This allows for an order of magnitude more precision than other leading protocols and creates a pricing accuracy that begins to rival that of sophisticated centralized exchanges. + +In this specific context, a “tick” refers to the smallest possible price increment within which liquidity can be placed in a concentrated liquidity AMM like Ekubo. The ability to utilize such incredibly small tick sizes allows for several profound benefits: + +* **Extremely precise liquidity placement:** Liquidity providers can deploy their capital with surgical accuracy, targeting the exact price ranges where they anticipate the most trading activity. +* **Tighter spreads:** This precision allows for narrower bid-ask spreads, which in turn enables more competitive and efficient markets for traders. +* **Lower slippage:** With liquidity being more densely packed around the current market price, traders experience significantly lower slippage, resulting in better execution for their trades. + +The collective result of these advantages is a virtuous cycle: LPs earn more fees on their capital, traders receive better prices on their swaps, and the entire system operates with a much higher degree of overall efficiency. + +To put this into practical terms, a deposit of just $1,000 of liquidity on Ekubo can be configured to perform as effectively as a $100,000 deposit on a less advanced AMM. This remarkable efficiency is a direct consequence of the extreme concentration made possible by Ekubo’s fine-grained tick architecture.  + +It is also worth noting that Ekubo still provides full support for users who prefer a more passive approach to liquidity provision. Anyone can easily create v2-style, full-range positions. Unlike concentrated liquidity, which typically demands active management and monitoring of positions, these full-range positions offer a simpler, “set-and-forget” exposure to the market, with no ongoing need to monitor price movements. To achieve this, LPs simply need to set the minimum range of their position to 0 and the maximum range to a very, very high number, effectively replicating the behavior of a traditional v2 pool. + +### Extension + +One of Ekubo’s most powerful and forward-thinking features is its extension system. This system empowers third-party developers to build entirely new and customized types of pools in a completely permissionless fashion. These extensions are not separate, siloed applications; instead, they embed their custom logic directly into the core of the Ekubo protocol. This ensures they remain fully compatible and composable with Ekubo’s broader ecosystem, which includes aggregators, user interfaces, and various other developer tools. + +Virtually every aspect of a transaction’s lifecycle can be customized: before, during, and after the core swap logic is executed. Developers can attach their extensions to specific pool interactions, modify the behavior of a pool at key execution points, or capture valuable on-chain data for analysis or other purposes. This unlocks an unprecedented level of flexibility and innovation. For example, pricing curves can be completely redefined to suit specific asset types, custom oracles can be seamlessly integrated, external protocols can be called upon during a swap, and even privacy-preserving logic can be embedded—all within Ekubo’s unified and efficient architecture. + +The outcome is a radically improved user experience for both LPs and traders. It also grants liquidity providers much greater control over how their capital behaves, with pools that can be configured to match precise, sophisticated strategies or to adapt dynamically to evolving market conditions. + +Three extensions that are already live within the Ekubo ecosystem perfectly showcase this remarkable flexibility: + +* **Limit Orders:** Users can place ultra-precise on-chain limit orders. Thanks to Ekubo’s highly concentrated liquidity, these orders can often achieve a level of accuracy that surpasses what is possible on most centralized exchanges. These trades are executed entirely on-chain, with no hidden fees, no off-chain components, and no reliance on third-party dependencies. With this extension, you can set up buy or sell orders far in advance, at a very specific target price, and allow the system to handle the execution automatically and trustlessly. +* **TWAMM Orders (DCA):** Ideal for executing large trades or for the gradual accumulation or distribution of an asset, Time-Weighted Average Market Maker (TWAMM) extensions allow users to execute long-duration orders entirely on-chain. This mechanism is designed to minimize slippage and overall market impact by breaking a large order down into infinitely small virtual orders over a specified period. This enables a native Dollar-Cost Averaging (DCA) experience directly on the protocol. You can gradually buy or sell an asset over hours or days without needing to manually manage dozens of individual orders. This TWAMM extension can be a particularly powerful tool for DAOs managing their treasuries. +* **Oracle Extensions:** These extensions provide a reliable and manipulation-resistant time-weighted average price (TWAP) by averaging a pool’s price over a user-defined period. This design, which relies on historical on-chain data, makes it significantly harder for malicious actors to exploit prices when compared to relying on external or spot-price oracles. + +It is crucial to note that all of these extensions are integrated into Ekubo without creating any form of liquidity fragmentation. Users can easily access and utilize them, and when a trader executes a swap through the Ekubo user interface, the smart router automatically takes all available pools—including standard, limit order, and TWAMM pools—into account to deliver the absolute best possible price execution. + +The potential for innovation with Extensions is practically infinite; the only real bottleneck is the creativity of our collective monkey brains. To give you a better sense of what is possible, here are a few examples of existing, successful protocols that developers could rebuild directly on top of Ekubo, likely with better optimization, a superior user experience, and greater gas efficiency than their current standalone versions: + +* A launchpad for new tokens, similar in spirit to Pump.fun. In fact, Moody is already actively developing such a product, with a Minimum Viable Product (MVP) expected to be ready for testing by mid-to-late summer. + +* A protocol for lending against concentrated liquidity positions, similar to Fluid. +* A perpetuals trading application, perhaps inspired by a model like Infinity Pools. +* For the privacy maximalists, Ekubo has already open-sourced the first iteration of privacy pools on Starknet. You can think of this as being similar to Tornado Cash, but with the added feature of being able to prove that your funds came from a specific, approved set of deposits without revealing which particular one was yours. You can find more details here. + +In summary, with Ekubo extensions, complex functionalities that once required the development of an entirely separate protocol can now be built directly on top of Ekubo. This allows new applications to instantly benefit from its deep, shared liquidity, its sophisticated routing infrastructure, its existing UI integrations, and the network effects of its broader ecosystem. + +### Withdrawal Fees + +Ekubo introduces a subtle yet profoundly powerful mechanism designed to more effectively balance the incentives involved in liquidity provision: withdrawal fees. The principle is simple, yet its impact on the practical dynamics of the market is significant. + +When you remove your liquidity from any given pool on Ekubo, you are required to pay a fee that is equal to that pool’s designated swap fee. This fee is taken directly from your principal deposit, not from the fees you have earned. This is a protocol-level fee, meaning it is enforced on every single withdrawal without exception, and it fundamentally changes the economic calculus and behavior of liquidity providers. + +In simple terms, if you create or deposit into a pool that has a 0.3% swap fee and you later decide to remove $10,000 worth of liquidity, you will be charged 0.3% on that withdrawal, which amounts to $30. This mechanism is specifically designed to discourage short-term, opportunistic strategies. It particularly targets Just-In-Time (JIT) liquidity providers—those who deposit a large amount of liquidity right before a large trade is executed in order to collect the fees, and then instantly pull their liquidity out. This practice is exploitative of passive LPs who remain exposed to price risk over the long term. + +Here’s a practical example of how this plays out: + +1. A mercenary LP identifies a large pending swap and drops $1,000,000 into a pool with a 0.05% fee, hoping to snipe a juicy arbitrage opportunity. +2. They successfully capture the fees from the large trade and attempt to withdraw their liquidity within the very same block. +3. Ekubo’s protocol automatically charges them a 0.05% withdrawal fee on their $1,000,000 principal, which amounts to $500. This is precisely the same amount they would have hoped to earn in swap fees. +4. The net result for the JIT provider is zero profit, minus the gas costs they incurred. + +This behavior is not explicitly banned by the protocol, but it is rendered economically unviable. + +On the other hand, long-term liquidity providers are not punished by this system. The longer you keep your liquidity in a pool, the more you will earn in swap fees, which makes the one-time withdrawal cost progressively more negligible over time. Furthermore, thanks to Ekubo’s ultra-efficient tick architecture, you need less capital to earn the same amount of fees, which makes the withdrawal fee even smaller in relative terms. + +It is also important to note that zero-fee pools are entirely possible and supported. This is what notably enables the creation of extensions like TWAMM (DCA) or on-chain limit orders without introducing any additional fees for the users of those features. + +So, what does this innovative model unlock? + +* **Fewer liquidity mercenaries:** Behavior that is detrimental to the health of the pool and harms passive LPs becomes significantly less profitable. +* **Better fee alignment:** It creates a simple, fair trade-off. If you, as a pool creator, want to charge traders a 0.3% swap fee, you should be prepared to pay that same 0.3% fee to exit the pool. +* **Incentives that favor deep, sticky liquidity:** The design naturally rewards liquidity that is concentrated, low-fee, and passive, which in turn improves trade execution for all traders. +* **Protocol revenue with a purpose:** The withdrawal fees are accumulated in the core protocol contract and can be withdrawn by the core owner. In Ekubo’s case, the owner is the governance DAO. Currently, 100% of these collected fees are directed towards a program that buys back EKUBO tokens from the open market. + +As of June 2025, over $1 million in fees has already been collected and utilized to support the token’s economy through a systematic buyback of the token. You can find all the transparent metrics related to the token buyback program here. This is real, sustainable value being captured at the protocol level without resorting to adding interface fees, implementing token taxes, or creating artificial inflation. + +### Ekubo’s DAO + +I know, the term “DAO” often elicits skepticism, and for good reason. But in the case of Ekubo, the DAO is not just a meme or a facade for centralized control. It is a genuine, functioning, and empowered governing body. + +While Ekubo, Inc., the development company led by Moody, is the primary contributor and driving force behind the protocol’s development (more on the team in Part V), it is crucial to understand that the company does not control the protocol. Ownership and control of Ekubo’s core smart contracts have been fully and irrevocably transferred to the Ekubo DAO. The DAO now governs the protocol entirely on-chain, making all key decisions through a transparent voting process. + +Ekubo, Inc. is simply one of many participants within the DAO. Despite holding a significant amount of voting power, it does not possess unilateral control. In fact, here’s an example of a proposal that did not pass, even though Ekubo, Inc. voted in favor. + +To date, over 40% of all governance proposals have come directly from the community, not from Ekubo, Inc. This demonstrates a healthy and active level of engagement. Any individual who has at least 100,000 EKUBO tokens delegated to their address has the power to submit a formal proposal for consideration. Governance on Ekubo is open, active, and genuinely community-driven. + +This robust structure gives EKUBO token holders full and ultimate responsibility over the protocol’s future direction. This includes several critical functions: + +* **Managing and upgrading the core smart contracts:** This adds a vital layer of security and community oversight. Most contracts on Starknet are upgradeable (whereas on Ethereum, most of the core and extension contracts developed by Ekubo Inc are immutable), but any upgrade can only be executed after a successful DAO vote. +* **Controlling the Ekubo treasury:** This includes managing the funds that are dedicated to growing the social layer and fostering the broader ecosystem. +* **Deciding how the buyback funds are allocated:** The community has the power to decide whether these funds are used for token burns, liquidity incentives, staking rewards, or other value-generating programs. + +If you hold EKUBO tokens and wish to take an active role in shaping the protocol’s future, I strongly encourage you to join the DAO discussions on Discord, particularly in the dedicated #town-hall channel. + +At this point in the analysis, you might be asking a very reasonable question: this all sounds impressive on paper, but in an already saturated AMM landscape that is heavily dominated by Uniswap, what truly gives Ekubo a sustainable competitive edge? + +The answer is elegantly simple: Ekubo doesn’t just replicate the architecture of Uniswap v4; it actively pushes it further and improves upon it. It aggressively optimizes every single layer of the technology stack and introduces new, powerful, native features to deliver an AMM that is demonstrably faster, leaner, and more flexible. + +Here is a breakdown of how Ekubo outperforms other AMMs in practice: + +1. **Unmatched gas efficiency:** Ekubo’s smart contracts have been rigorously and continuously optimized, making the protocol 20–30% cheaper to use than other leading AMMs across all primary functions, including swaps, LPing, and pool creation. Don’t just trust this claim, verify it for yourself: run identical operations on Ekubo and another AMM like Uniswap, and compare the gas usage. The results speak for themselves. +2. **Hyper-precise liquidity deployment:** As previously detailed, Ekubo utilizes tick sizes that are 100 times smaller than those found in Uniswap v3/v4. This enables LPs to concentrate their liquidity with surgical precision. The direct result of this is tighter spreads, which means better prices for traders, and significantly higher fee efficiency for LPs, even when they deploy smaller amounts of capital. +3. **Feature-rich by default:** Functionalities that are often an external plugin, a separate protocol, or a complex, layered solution elsewhere are native and seamlessly integrated into Ekubo. On-chain limit orders, TWAMM (DCA) functionality, and robust Oracle pools are all fully composable, operate entirely on-chain, and are deeply integrated into Ekubo’s core logic from day one. +4. **Designed for Aggregators:** Ekubo’s extreme efficiency directly benefits aggregators, which is where the majority of real, organic trading volume flows in DeFi. By offering the best net execution price, Ekubo naturally attracts more volume from these aggregators, creating a powerful growth loop. More volume leads to higher fees for LPs, which attracts more TVL. More TVL leads to deeper liquidity and even better execution, which in turn attracts even more volume from aggregators. This also means more revenue for the Ekubo protocol itself. + +**5. Relentless shipping:** The core development team continues to ship new features and improvements at an aggressive and impressive pace. They were one of the first DeFi protocols to deploy 1-click swap + LP on Ethereum. They are constantly making low-level improvements and gas optimizations to the core contracts. They also created and open-sourced the first iteration of Privacy Pools on Starknet, demonstrating a commitment to innovation beyond just their core product. + +**6. A Token that actually captures value:** Most AMM tokens are effectively deadweight. They offer no revenue share, no burn mechanism, no buybacks. Ekubo completely flips this script: + +* + It had a fair launch with no Venture Capitals (VCs), meaning the full float of tokens was available from day one. + + 100% of the protocol’s withdrawal fees go directly to the DAO. + + The DAO then uses these fees to systematically buy back EKUBO tokens on the open market. This creates a direct, powerful, and transparent alignment between the usage of the protocol and the value accrued by its token holders. We will delve deeper into this in the Tokenomics section (IX). + +## V. Team and backers + +With its governance now transitioned to a Decentralized Autonomous Organization (DAO), Ekubo has officially moved beyond the control of any single entity. This marks a pivotal moment in its evolution towards becoming a truly decentralized piece of financial infrastructure. But to understand where it’s going, it’s essential to look at its origins. Who was the architect behind this powerful protocol? Who continues to drive its development forward? And how is the DAO structure shaping its future? + +### The builder behind the protocol + +The initial creation and ongoing maintenance of the Ekubo protocol are the work of Ekubo, Inc. This corporation is spearheaded by its founder, Moody Salem, a well-regarded veteran of the Ethereum space and one of the most significant contributors to the development of modern Automated Market Maker (AMM) infrastructure. His track record is a testament to his expertise and deep understanding of decentralized exchange mechanics. + +Moody’s journey is deeply intertwined with the history of Uniswap, the leading DEX on Ethereum. As the fifth employee and Chief Engineer at Uniswap Labs from April 2020 to May 2022, he was instrumental in shaping the user experience and core functionality that millions of users rely on today. He was responsible for writing a significant portion of the early Uniswap web interface, creating the foundational token-lists system, and building the very first routing algorithm for swaps between the v2 and v3 protocols. He also personally committed approximately 50% of the v3 smart-contract codebase. Furthermore, he led the architectural design for Uniswap v4. Even after starting Ekubo, he continued to serve as a technical advisor to Uniswap through 2023. His ability to execute is equally impressive; in less than three months, he single-handedly coded the entire foundation of the Ekubo protocol and deployed it to the Starknet Mainnet. + +This reputation for producing clean, elegant, and highly secure code is not just an internal metric; it is widely recognized and echoed by his peers and other industry OGs. For example, you can see a strong public vote of confidence in Harikrishna’s endorsement. Beyond its founder, Ekubo, Inc. operates with a deliberately lean and engineering-centric philosophy. The team is small, focused, and remains the primary contributor to the protocol’s development. For those interested in the specifics of its operational framework, a detailed overview of the company’s mandate, its operating budget, and a public pledge not to sell its tokens can be found within this official DAO grant document. + +### Transition toward a multi-team ecosystem + +The long-term vision for Ekubo extends far beyond a single development team. The goal is to foster a vibrant and decentralized ecosystem. This model envisions a slim, highly specialized core team at the center, responsible for the most critical aspects of the protocol, surrounded by an ever-expanding ring of independent ecosystem contributors. This structure promotes resilience, innovation, and community ownership. + +The first concrete steps in this direction involve opening up key operational areas like marketing and business development to the broader community. This process is already underway, with several community groups formally expressing their interest in taking ownership of these crucial functions, aiming to expand Ekubo’s reach and integration across the crypto landscape. + +The philosophy is clear: maintain a tight, expert group for core protocol maintenance to ensure stability and security, while simultaneously pushing for greater autonomy and permissionless contribution at the edges of the ecosystem. This allows the protocol to scale its operations and community engagement far more effectively than a traditional, centralized company ever could. + +When it comes to financial backers, the term doesn’t quite fit Ekubo’s journey. The protocol has not followed the typical venture capital funding route. Instead, its most significant financial endorsement came in the form of the largest Catalyst grant ever awarded by the Starknet Foundation. Ekubo received 6 million STRK tokens, a figure that dwarfs the 3 million STRK given to the next-largest recipient. This grant represents a massive vote of confidence from the Starknet Foundation. + +In another significant move, Moody Salem proposed a strategic partnership directly to the Uniswap community. The proposal involved a $12 million investment, in the form of 3 million UNI tokens, from the Uniswap treasury into Ekubo, which would have placed a $60 million valuation on the protocol. The Uniswap community approved it. However, in a surprising turn, the Ekubo team ultimately decided not to proceed with the deal, choosing to forge its own path.  + +To be indirectly backed by the Starknet Foundation and to have a strategic investment approved by the Uniswap community speaks themself about the perceived quality and potential of the protocol. Probably nothing. + +## VI. Metrics + +### 1. On Starknet + +When Ekubo first launched on Starknet, it entered a competitive field populated by several established AMMs. However, just twelve months later, the landscape has been completely redrawn. Ekubo now commands a staggering 60% of the total AMM Total Value Locked (TVL) on Starknet. Even more impressively, it captures the vast majority of all trading volume on the network, whether that volume is executed directly on its interface or routed through popular DEX aggregators like AVNU and Fibrous. + +The result has been a near-total consolidation of the market, a comprehensive outmaneuvering of all competitors. This dominance is particularly noteworthy given that its main rivals, mySwap and JediSwap, are both based on the v3 AMM model, and another competitor, SithSwap, is specifically optimized for stablecoin pools (like USDC/USDT and wETH/ETH), which are typically high-volume pairs. + +The secret to this success lies in Ekubo’s extreme optimization. The protocol is so efficient in its design that the majority of swaps routed by aggregators on Starknet are funneled through Ekubo’s liquidity pools, and this was already true when its TVL was still small. The superior execution prices offered by Ekubo made it the logical choice for any aggregator seeking the best possible deal for its users. + +Back in September 2023, I wrote: “*As the only UniV4-style AMM on Starknet, it is likely that Ekubo will attract TVL from other AMMs in the coming weeks.*” This is precisely what happened, as liquidity providers migrated their capital from less efficient platforms to Ekubo in search of higher returns and better performance. + +### 2. On EVM + +While its EVM expansion is still in its early phase, and currently limited to Ethereum, Ekubo is already showing very promising signs. As of August 13th, the number of new Ekubo users keeps climbing, while volume has seen exponential growth in recent weeks. + +What makes this performance truly remarkable is the context of its TVL. With only around $20 million in TVL, Ekubo had already positioned itself among the top 3 DEXs on Ethereum by daily trading volume. The most telling metric, however, is its Volume-to-TVL ratio. Among all the top DEXs on Ethereum, Ekubo has by far the highest ratio. + +(Screenshot from May 24th; unfortunately, DeFiLlama has since removed the Volume/TVL ratio comparison, but the numbers look even better now for Ekubo, with a ratio above 30 on some days) + +This ratio (30) means that every $1 of TVL on Ekubo generates $30 in trading volume per day 🤯. This level of capital efficiency is unparalleled and serves as the clearest possible indicator of the protocol’s superior design and its ability to offer extremely competitive pricing for traders. + +### 3. Globally + +The combination of its dominance on Starknet and its burgeoning success on Ethereum has led to impressive overall financial performance. Since its launch, Ekubo has already generated over $1M in revenue. And that’s just on Starknet. With its EVM expansion now happening, I expect that number to grow rapidly: + +In summary, the data paints a clear and compelling picture. Ekubo has established itself as the undisputed liquidity monopoly on its home chain of Starknet, while simultaneously proving itself to be the single most capital-efficient DEX on the highly competitive Ethereum mainnet. + +## VII. How Ekubo Can Grow + +This analysis demonstrates that Ekubo can be viewed as the market’s most advanced and efficient liquidity infrastructure. Given that trading is crypto’s primary and most enduring use case, and that all trading activity fundamentally depends on the availability of deep and efficient liquidity, Ekubo is perfectly positioned for rapid and substantial scaling. Several key factors are poised to accelerate its growth trajectory in the coming months and years. + +### 1. Starknet Growth + +This is a foundational element of Ekubo’s growth strategy. As detailed in the metrics section, Ekubo has achieved such a dominant position on Starknet, in terms of both TVL and capital efficiency, that it is now set to passively capture the upside from the entire network’s growth.  + +In terms of liquidity, Ekubo is the foundation, accounting for over 60% of all AMM liquidity on the network. In terms of volume, its extreme optimization and unmatched capital efficiency mean that it offers the best execution for traders. Consequently, the vast majority of volume from DEX aggregators on Starknet is routed through Ekubo’s pools. AVNU, the leading DEX aggregator, which powers most of the trading UX across Starknet, is deeply integrated into the ecosystem, and a major part of its liquidity power comes from Ekubo. See graphic below showing how AVNU is the invisible engine behind most trading flows on Starknet. + +So as Starknet grows, and I truly believe it has now found its PMF and is entering a phase of rapid adoption, Ekubo will continue to benefit passively. Here are some signs of the Starknet revival: After nearly a year of low activity, users are coming back onchain. + +Starknet is now a top 5 Rollup by TVL, and one of the most active, consistently handling between 3 and 10 TPS daily. + +A Starknet-powered app is ranking ahead of Airbnb, Uber, Strava, and Booking. And this resurgence is only just beginning; several major catalysts are lined up: + +* Lombard launch – the leading BTC LST coming to Starknet +* Extended – a major perp DEX launching on Starknet L2, offering the same features as Hyperliquid/Paradex +* Rosettanet – EVM wallet compatibility +* Two major interoperability protocols integrating Starknet in Q3/Q4 2025 +* Bitcoin staking +* BTCfi campaign launch by the Starknet Foundation + +All of this activity will flow through Starknet’s DeFi stack, and as the dominant liquidity layer, Ekubo will passively capture the upside. + +### 2. Expansion into the EVM Ecosystem (and also CairoVM!) + +Ekubo has already established strong metrics on Ethereum L1, and that launch is only phase one. Because the codebase is now EVM-compatible, the protocol can be deployed to any major EVM chains with minimal effort; Base, Arbitrum, BSC, HyperEVM (Hyperliquid), Sonic, Monad, and more. In fact, some teams are already courting Ekubo for a launch; Sonic’s core developer Andre Cronje publicly invited the project to do that on Sonic 😉. Bottom line: Ekubo can scale its market share horizontally across chains whenever the DAO decides the timing is right. + +On Starknet, Ekubo is written in Cairo; the rise of Cairo-native chains built on the Starknet Stack widens the runway further. Paradex (perp DEX), Agent Forge (AI marketplace), Eara (RWA infrastructure) and StarkPay (payments chain) are already building Cairo-based chains. As that ecosystem expands, Ekubo’s Cairo code can be redeployed to multiple L2s just as easily as its Solidity version moves within the EVM world. + +### 3. Deep Liquidity & Efficiency: A Builder Magnet + +Thanks to its superiority over other AMMs in terms of gas and liquidity efficiency, Ekubo is set to continuously attract more TVL. And as it does, a flywheel effect kicks in. + +Ekubo is already shaping up to be the best trading liquidity infrastructure, and thanks to extensions, anyone can build on top to create advanced DeFi use cases, tapping into its deep liquidity and unmatched efficiency. A few examples of what can be built using Ekubo’s extension framework: + +* AMM x Money Market hybrid → Fluid like use case +* Max leverage, no liquidation → Infinity Pools like use case +* A better version of Pumpfun (currently in the works, led by Moody) + +On Ekubo itself already available: + +* DCA (TWAMM) +* Limit orders +* Oracle pools +* Private pool initiative on Starknet (not production ready) + +My view: If Ekubo continues to attract liquidity across EVM chains, it will establish itself as the go-to AMM infrastructure for advanced DeFi; the foundation where developers build any use case that demands deep, capital-efficient liquidity. And the beauty of it? All these apps will be natively integrated into Ekubo and composable by design. + +### 4. BTCFI Growth + +While fully trustless BTC DeFi isn’t here yet, BTCFI is already growing. One of the main use cases is on-chain BTC trading and liquidity providing. Crucially, Ekubo is: + +* The most efficient AMMs out there +* The best infra layer for traders and LPs + +So it’s perfectly placed to benefit from the BTCFI narrative. Even more bullish? The chain where Ekubo dominates (Starknet) is actively working to become Bitcoin’s execution layer, making it the most compelling infrastructure to bring BTC at scale. + +One example: Lombard, the leading BTC LST, is coming to Starknet, and Ekubo will be the go-to place to provide liquidity and trade it. + +### 5. DEX Growth vs. CEX + +As CEX dominance declines in favor of DEXs, Ekubo is naturally set to benefit from this onchain trader migration. + +#### TL;DR + +Ekubo is perfectly positioned to benefit, both passively and actively: + +* Ride Starknet’s accelerating growth. +* Expand rapidly across EVM (and Cairo) chains. +* Leverage extensions to draw builders and TVL. +* Capture the emerging BTCFi wave. +* Benefit from the long-term shift of volume from CEXs to DEXs. + +By deploying across multiple chains, Ekubo diversifies risk while massively scaling its potential. And perhaps the most powerful aspect of Ekubo’s positioning: once it has accumulated enough TVL, it no longer needs to acquire users directly, most of the volume flows passively through aggregators. All it needs is a minimum amount of liquidity on each new chain, aggregator integration… and the passive flywheel takes over. + +## VIII. Tokenomics + +Not long ago, my research led me to an insightful article published by Binance Research titled, Sustainable Tokenomics: Questions Every Founder Should Think About. This piece thoughtfully outlines the principles that contribute to a robust and enduring token economy. The timing of this article was particularly relevant, as it emerged during a period of significant market correction and scrutiny. The industry was witnessing the dramatic downfall of numerous projects that had launched with excessively high valuations but very small initial circulating supplies. This model frequently created a situation where VCs and sophisticated market makers could secure massive profits, often to the detriment of everyday retail participants who would buy into the hype at inflated prices. + +What was genuinely striking to me upon reading the Binance article was the realization that every single best-practice criterion they recommended for building sustainable tokenomics had not only been considered but had already been meticulously implemented and even optimized by the Ekubo protocol. This was accomplished well in advance of the widespread industry backlash against exploitative token models and long before Binance published their analysis. It was a clear indication that Ekubo’s design philosophy was fundamentally sound and ahead of its time. + +To construct a token economy that is not only healthy but also poised for long-term success, it is proposed that there are four primary design objectives that must be addressed. These pillars form the foundation of a fair and functional system that aligns the incentives of all participants, from the core team to the newest community member. These objectives are: + +* A Fair Distribution Of The Token Supply +* Sustainable and Predictable Supply Emissions +* The Creation of Distinct and Intrinsic Demand For The Token +* The Fostering of an Active and Genuinely Decentralized Governance Structure + +Beyond these core token-centric principles, there are several other critical considerations that, while not strictly part of the tokenomic model itself, can profoundly influence a token’s performance and the overall health of the protocol. These include: + +* The initial Valuation at the time of the token’s launch +* Complete Transparency regarding team token vesting schedules and any potential sales + +Let’s now proceed to examine each of these crucial points in greater detail, exploring how Ekubo’s approach stands as a benchmark for excellence in each category. + +### 1. Fair Distribution + +From its very inception, Ekubo demonstrated an unwavering commitment to a fair and equitable distribution of its native token, EKUBO. The protocol made the deliberate decision to directly allocate the vast majority of the total supply, precisely 66.66%, to its community members. This was not a monolithic giveaway but a carefully structured two-pronged approach designed to reward early supporters and foster a broad, decentralized base of token holders. + +The first part of this community allocation involved an airdrop of 33.33% of the total supply. This portion was distributed to the early users of the protocol, the pioneers who provided liquidity and generated trading volume in the platform’s nascent stages. This served as a retroactive reward for their faith and participation, ensuring that those who helped build the foundation of Ekubo were given a significant stake in its future governance and success. + +The second part of the community distribution, another 33.33%, was sold to the public through a series of Dollar-Cost Averaging (DCA) orders directly on the open market on Starknet. This public sale was conducted over an extended period of two months, running from May 24, 2024, to July 23, 2024. This method was strategically chosen for several reasons. Firstly, it allowed the protocol to bootstrap its own treasury in a transparent and decentralized manner, accumulating valuable assets like ETH and USDC without relying on private funding from VCs. Secondly, the extended duration gave everyone in the broader community, regardless of their connections or capital size, an equal opportunity to acquire the token at an early stage and at what was a very low initial valuation. + +The remaining 33.33% of the total token supply was allocated to the core team and the project’s primary contributor, Ekubo Inc. However, this allocation came with a powerful and public commitment from the team. They have formally pledged not to sell any of these tokens for as long as they are actively building and employed by the Ekubo DAO. This is a profound statement of long-term alignment. As they stated: + +> *We also commit to never selling any of the allocated 33.3% of EKUBO tokens from the company treasury for as long as the company exists. This means the company will always be incentive aligned with the success of the protocol.* Source + +Currently, Ekubo Inc. is under contract with the DAO to continue its development work until at least July 28, 2026. Their grant proposal further solidifies this long-term view: + +> *We are requesting a grant of ~$1.5M to sustain the company in this role for at least the next 2 years without additional funding. This should be the only grant Ekubo, Inc. ever requests from the DAO: in the future, the company should be sustained by revenue from the one-third of total EKUBO tokens it holds.* Source + +Given these public commitments and contractual agreements, it is reasonable to assume that this substantial 33.33% block of the token supply will remain static and off the market until at least the middle of 2026, and quite possibly for a much longer period. This removes a significant source of potential sell pressure that plagues many other projects with large, ambiguously-vested team allocations. + +### 2. Sustainable Supply Emissions + +The topic of supply emissions and inflation is often one of the most complex and contentious aspects of tokenomics, frequently involving intricate vesting schedules, unlock cliffs, and continuous rewards that dilute the value for existing holders. Ekubo’s approach to this challenge is a masterclass in simplicity and sustainability. In fact, it is even more straightforward than its distribution model. + +The simple truth is this: all 100% of the EKUBO tokens are already in circulation. There is zero inflation. There is no vesting schedule. There are no future unlocks. This means that the total supply of the token is fixed and will never increase. This is a stark contrast to the vast majority of DeFi protocols, which often rely on inflationary token rewards to incentivize liquidity or other desired behaviors. While those incentives can be effective in the short term, they invariably create persistent sell pressure as recipients cash out their rewards, and they dilute the ownership stake of every long-term holder. + +By having the entire supply circulating from the outset, Ekubo has completely eliminated this risk of future inflation. This leads to a very rare and desirable characteristic in the crypto space: the Market Cap (MC) of the token is equal to its Fully Diluted Valuation (FDV). For investors, this provides a level of clarity and certainty that is incredibly valuable.  + +### 3. Distinct Demand For The Token – Product is integral to long-term token performance + +A token’s long-term success is intrinsically linked to the existence of genuine, sustainable demand. Without a clear reason for people to acquire and hold the token beyond pure speculation, its value is built on a fragile foundation. Ekubo has engineered a system where EKUBO token holders are directly and continuously aligned with the growth and success of the protocol itself through a powerful revenue-sharing and buyback mechanism. + +The protocol generates revenue through withdrawal fees: every time a LP decides to remove their assets from a liquidity pool, they are charged a fee. This fee is calculated as being equal to the pool’s designated trading fee tier (e.g., 0.05%, 0.30%, etc.) and is applied to the entirety of the LP’s position upon withdrawal. + +Crucially, these collected fees are not simply held in the treasury. Instead, they are programmatically used to buy back EKUBO tokens from the open market. This process creates a constant and reliable source of buying pressure for the token. As of August 13th, 2025, the Ekubo DAO has already bought back over 197,000 EKUBO tokens, which represents approximately 2% of the total supply. This entire process is completely transparent and can be tracked in real-time by anyone on the blockchain right here. + +Since its launch, Ekubo has generated over $1 million in protocol revenue, a figure that continues to climb steadily. + +This revenue generation and subsequent buyback create a powerful, self-reinforcing growth loop. As discussed in Section VII (How Ekubo Can Grow), the protocol’s future growth can be driven by five key factors. The core of this flywheel is that as Ekubo attracts more Total Value Locked (TVL), it can offer better trade execution with lower slippage. This superior execution naturally leads to more trading volume being routed through Ekubo by aggregators and individual traders. More volume translates directly into higher Annual Percentage Rates (APRs) for liquidity providers. These attractive returns, in turn, incentivize even more TVL to flow into the protocol. And, of course, more TVL means more withdrawal fees, which fuels more revenue and larger token buybacks, completing the virtuous cycle. This is especially potent in concentrated liquidity pools, where LPs must be more active in managing their positions, leading to more frequent withdrawals and deposits, thus generating more fee revenue. + +A natural question arises: what will the protocol do with this growing stash of bought-back tokens? The beautiful answer is that the decision rests entirely with the DAO, meaning the EKUBO token holders themselves have complete control. Several compelling options have been discussed within the community. One possibility is to permanently burn the repurchased tokens, which would make the token deflationary and increase the scarcity and value of the remaining supply. Another option is to distribute these tokens as rewards to stakers, particularly those who are active participants in governance, thereby incentivizing informed and engaged decision-making. A third strategy could be to use the tokens to fund targeted incentives for attracting additional TVL to new or strategic liquidity pools. + +Again, the power lies with the community; EKUBO holders are the ultimate arbiters of the protocol’s destiny. At present, a portion of the bought-back supply is being strategically deployed to incentivize liquidity for Ekubo’s expansion onto the Ethereum L1 mainnet, a decision made by the DAO. You can learn more about this specific initiative here. + +Furthermore, the utility and demand for the EKUBO token extend beyond the protocol’s internal mechanics. It is being actively integrated across the wider Starknet DeFi ecosystem, further cementing its role as a core asset. For instance, it can be used as a collateral or lending asset on Vesu and Nostra Finance. It is also accepted as a means to mint the $CASH stablecoin on the Opus protocol. In a particularly useful integration, you can even pay for network gas fees with EKUBO when using the Ready wallet, allowing users to interact with the entire Starknet ecosystem using their EKUBO holdings. + +### 4. Active and Decentralized Governance + +A truly decentralized protocol requires more than just a governance token; it needs an active, engaged, and empowered community to guide its evolution. In this regard, the Ekubo DAO stands out as one of the most active and effective decentralized autonomous organizations in the entire DeFi landscape. + +Since its governance was activated, there has been a remarkable level of activity, with a total of 31 formal proposals being put to a vote. Of these, 29 have been successfully passed, while 2 were rejected by the community, demonstrating that the voting process is not a mere formality but a genuine check on power. What is particularly encouraging is the source of these proposals. While 17 originated from the core development team at Ekubo Inc., a significant 14 proposals were entirely community-driven, showcasing a healthy and proactive governance culture where ideas can emerge from anywhere within the ecosystem. + +Some of the notable proposals that have shaped the protocol’s trajectory include: + +* The initial **Governance activation** (June 2024), which officially handed control over to the token holders. +* A **Governance airdrop** designed to reward the first delegates and voters, encouraging early participation. +* The **Ekubo Inc. contract/grant request** (July 2024), which transparently outlined the team’s funding for the next two years. +* A **Core contract upgrade** to enhance the protocol’s functionality and security. +* The implementation of a **Permissionless revenue buyback system**, allowing anyone to trigger the buyback mechanism. +* A proposal for **Diversified buyback assets**, giving the DAO more flexibility in its treasury management. +* The establishment of a formal **Audit + bug bounty program** to bolster security. +* A decision on **STRK staking participation** to optimize the DAO’s treasury yield. +* The allocation of an **EVM audit budget** for the protocol’s expansion to Ethereum. +* The creation of **Ethereum deployment incentives** to bootstrap liquidity on the new chain. + +This high level of engagement is supported by a significant portion of the token supply being actively used for governance. Currently, over 60% of the total EKUBO supply is staked, making it eligible to participate in voting on these critical proposals. This high staking ratio is a strong indicator of a committed and long-term-oriented holder base. Note that there is no lockup period; holders can unstake at any time. + +### 5. Low valuation on launch + +One of the most significant barriers for retail investors in the crypto space is gaining access to promising projects at a fair and early valuation. Too often, private rounds and insider deals allow VCs and well-connected individuals to buy in at a fraction of the price that the public is later offered. Ekubo completely upended this inequitable model. + +The two-month DCA sale, which ran from May 24 to July 23, 2024, was the primary mechanism for the public to acquire EKUBO tokens. This sale, conducted directly on the open market using Ekubo’s own DCA extension, allowed the DAO to sell a portion of its tokens daily. This methodical and transparent process resulted in the community being able to purchase EKUBO at an approximate Fully Diluted Valuation (FDV) of just ~$10 million. The average price paid by participants during this extensive sale period was around $1.02 per token. This provided a rare opportunity for ordinary retail buyers to invest in a top-tier protocol at an entry point that is typically reserved for the earliest private investors in other projects. + +Through this innovative and fair DCA sale, Ekubo successfully built its initial treasury by selling a total of 3,269,920 tokens. In exchange, the DAO treasury acquired a diversified portfolio of assets, including: + +* 343.675 ETH +* 1,204,770 USDC +* 1,549,920 STRK + +This approach not only ensured a fair launch but also provided the DAO with a robust and well-capitalized treasury from day one, ready to fund future development and strategic initiatives without being beholden to any external venture capitalists. + +### 6. Transparency over team vestings / sales + +In the often opaque world of cryptocurrency projects, a lack of clarity around team tokens, vesting schedules, and potential insider selling can create significant uncertainty and risk for investors. Ekubo addresses this concern with radical transparency and a simple, verifiable structure. + +As previously mentioned, the entire token supply is live and available on-chain. This means there are no complex vesting schedules to track, no looming “unlock” dates that could flood the market with new supply, and absolutely no VCs waiting in the wings to dump their discounted bags on the public. The 33.33% share of the supply allocated to the team is held in a transparent wallet, and its contents can be tracked by anyone at any time here. + +Furthermore, the revenue buyback contract is fully on-chain and is triggerable by anyone in the community. This means the process of converting protocol revenue into token buybacks is not dependent on the core team; it is a decentralized function that the community can initiate, ensuring that the mechanism works as intended, always. This commitment to on-chain transparency and verifiable actions builds a deep level of trust and removes the risks associated with hidden supply and opaque team dealings. + +#### TL;DR of the 6 key points on tokenomics + +* **Fair distribution:** A clear and equitable split, with 66.6% of the supply going to the community (divided between a 33.3% airdrop and a 33.3% open market sale) and the remaining 33.3% allocated to the team under a public no-sell commitment. +* **Zero emissions:** The entire 100% of the token supply is already circulating on the market. This means the Market Cap equals the Fully Diluted Valuation (MC = FDV), completely eliminating the risk of future token inflation. +* **Clear token demand:** Protocol revenue is used to fund continuous token buybacks, creating constant buying pressure (with nearly 200,000 EKUBO tokens already repurchased). EKUBO also has growing utility across the DeFi ecosystem as collateral, for lending, in governance, and as a token to pay for gas fees on Starknet. +* **Active, decentralised governance:** The DAO is highly active, with 31 proposals voted on, half of which were initiated by the community. A high staking rate of 62% of the total $EKUBO supply ensures robust and decentralized decision-making. +* **Low launch valuation:** The extended two-month DCA sale allowed the public to acquire EKUBO at an approximate $10M FDV, giving retail participants the same kind of early entry point that insiders typically receive in private rounds of other projects. +* **Full onchain transparency:** There are no hidden VC unlocks or future emission schedules. Every aspect of the token supply and the team’s holdings is publicly traceable and verifiable on the blockchain. + +Ekubo is actively breaking the cycle of what can be called “retail extractor” tokenomics, a model that has unfortunately become common in the industry. Instead of launching with a low float and high valuation designed to benefit early insiders, Ekubo launched from day one with a low-valuation, high-float model (with 100% of the supply floating from the start). The team made the conscious decision not to take any shortcuts by accepting private funding, choosing instead to fully bootstrap the protocol through its public sale. This commitment to fairness means that any large entity wishing to acquire a significant position, such as the notable crypto investment firm Delphi Digital, had to do so by purchasing tokens directly from the open market, on the same terms as any other participant. + +When compared to its top competitors in the AMM space by trading volume, the difference in tokenomic philosophy is stark and immediately apparent. + +It is clear that Ekubo’s tokenomics are designed with a focus on fairness, transparency, and long-term sustainability. + +## IX. Risks + +Despite Ekubo’s exceptionally strong fundamentals and well-designed model, it is essential for any thorough analysis to consider the potential risks that remain. No project is without its challenges, and being aware of them is crucial for making informed decisions. + +The first, and arguably the most significant risk at this stage of the project’s life, is that its development and strategic direction are still heavily driven by a very small team, and in particular, by its founder, Moody. At present, a vast amount of the protocol’s innovation, vision, and execution continues to revolve around him. While the long-term vision is for the DAO to become progressively more autonomous and take on a greater share of the responsibility for the protocol’s future, this is a gradual process. It will likely take a considerable amount of time before Moody’s role can be sufficiently decentralized to the point where his potential departure would have a limited impact on the protocol’s continued success. To be perfectly clear, there has been no public indication whatsoever that he has any plans to step away; this is simply an acknowledgment of the key-person risk that is common in many early-stage projects. + +The second notable risk is related to a strategic decision made by Moody and Ekubo Inc. to not actively focus on marketing and business development activities. Their rationale is to remain laser-focused on building the best possible core infrastructure. The areas that Ekubo Inc. will not be focusing on, and where the protocol would greatly benefit from broader ecosystem participation, include: + +* The development of advanced tooling for liquidity providers. +* Sophisticated analytics platforms, similar to revert.finance. +* Automated liquidity management solutions, such as those offered by Arrakis. +* Advanced delegate and governance tooling, like Tally or Agora. +* In-depth market analytics, for example, through community-built Dune dashboards. +* Integrations with aggregators and advanced routing systems (e.g., AVNU). +* General marketing and community management efforts. +* Organizing hackathons, sponsoring events, and representing the protocol at conferences. +* Creating user guides and comprehensive documentation. +* Managing the protocol’s official X (formerly Twitter) account. +* Pursuing listings on centralized exchanges and other token integrations.source + +While the logic behind this focused approach is sound from a product development perspective, it does come with tangible short-term consequences. Ekubo currently has relatively low visibility on platforms like X and within the broader narrative surrounding decentralized exchanges. This lack of marketing presence could slow down its adoption rate. Encouragingly, discussions are already happening within the community about how to address this, with various members and groups beginning to formulate proposals to take on these important roles. + +Another risk to consider is that Ekubo’s revenue model is entirely dependent on its capacity to attract and retain a large base of liquidity. While it may very well be the most capital-efficient and gas-efficient AMM in existence, efficiency alone is not always sufficient to guarantee the inflow of fresh TVL from across the crypto ecosystem. To date, the protocol’s growth in attracting TVL from the Ethereum mainnet has been steady but relatively slow, highlighting the challenge of competing for liquidity in a crowded marketplace. + +Lastly, as is the case with any protocol in the DeFi space, the risk of smart contract vulnerabilities is ever-present. A bug or exploit could lead to a significant loss of funds. That being said, Ekubo takes extensive measures to mitigate this risk. The protocol adheres to a robust audit process, ensuring that every major product release or significant contract upgrade undergoes a formal review by reputable security firms. You can find a comprehensive list of all of Ekubo’s audits here. Furthermore, the risk is significantly tempered by Moody’s unmatched credibility and expertise in the field. As a key architect who wrote a substantial portion of Uniswap v3 and led the design for the highly anticipated Uniswap v4, his track record is impeccable. He is a true leader in the space, trusted by many of the most respected figures in DeFi. + +## Conclusion + +In the dynamic and ever-evolving landscape of cryptocurrency, trading consistently remains its largest and most enduring use case. Within this domain, Ekubo is diligently building what is arguably the most advanced and efficient liquidity layer to power this activity. The protocol is not just an incremental improvement; it represents a fundamental step forward in the design of automated market makers. + +Ekubo is engineered to provide a superior experience for every type of participant in the DeFi ecosystem. Whether you are a high-frequency trader seeking the best possible execution, a liquidity provider aiming to maximize your capital efficiency and yield, a savvy investor hunting for the next protocol gem, or a developer building the future of finance, Ekubo delivers the tools you need and does so more effectively than any other platform. + +If you are a **trader**, your primary concern is best-in-class execution. This means getting your trades filled with minimal slippage, having access to deep liquidity to handle large orders, and paying the lowest possible gas fees. Ekubo delivers on all these fronts by design. Its architecture, which features ultra-concentrated liquidity, a unique singleton contract model, and the innovative Till pattern, ensures unparalleled efficiency. You have the flexibility to swap directly on the Ekubo interface (using market orders, limit orders, or even sophisticated DCA strategies) or to access its liquidity through an aggregator on either Ethereum or Starknet. + +If you are a **liquidity provider (LP)**, your goal is to do more with less capital. Ekubo offers top-tier capital efficiency, allowing you to concentrate your liquidity with incredible precision. Its tick sizes can be as small as 1/100th of a basis point, which is 100 times smaller than what is offered by major competitors. This granularity enables you to deploy your capital exactly where it will be most effective, automate your strategies, and keep your positions in range for longer, thereby maximizing your fee-earning potential. + +If you are a **gem hunter**, you are looking for promising, early-stage protocols with strong fundamentals and significant upside potential. With Ekubo, you are early to one of the most promising projects in all of DeFi. Its token has a 100% float, there is no VC overhead creating future sell pressure, and there is no off-chain mechanism for value extraction. All value generated by the protocol flows directly back to the protocol itself and, by extension, to its token holders. With its multi-chain expansion having only just begun, the potential for growth is immense. + +If you are a **DeFi builder**, Ekubo provides you with a modular, permissionless, and incredibly powerful set of infrastructure. Through its innovative extensions system, you can deploy any DeFi primitive you can imagine directly on top of what is the most efficient and versatile liquidity layer in the entire space, saving you time and resources while giving your application a competitive edge from day one. + +Whoever you are, and whatever your goals are in the world of decentralized finance, Ekubo gives you the edge. + +When I first wrote about this topic back in September 2023, Ekubo already looked like the AMM endgame. In the time that has passed since then, it has done nothing but consistently prove that thesis to be correct. Its progress has been relentless, and its design has proven to be robust and effective. + +Ekubo looked good before. Now, it looks inevitable. + +None of the content presented in this document constitutes financial advice. Please remain vigilant, stay SAFU, and always conduct your own thorough research before making any investment decisions. + +--- +Sources: + - https://www.starknet.io/blog/starknet-may-recap/ +--- + +## Starknet’s May recap | Starknet + +Home  /  Blog + +Bitcoin, S-Two and other exciting updates summarizing May 2025 for Starknet + +Written by: Lyskey + +Jun 16, 2025 · 5 min read + +## **Bitcoin Use Cases on Starknet Are Getting Real** + +May was wild for Bitcoin innovation on Starknet. The biggest highlight? Asset Runes. + +These are Bitcoin-native assets that give users 1:1 exposure to Ethereum tokens, right from the Bitcoin chain. The rollout kicked off with USDC, making it the first stablecoin natively available on Bitcoin. You can already trade it and provide liquidity on DotSwap. + +And there’s more coming — ETH, STRK, RWAs, NFTs… + +Even better? Bitcoin Runes are now bridgeable and tradable on Starknet. That means the Runes crowd can now experience smooth UX and play around with DeFi tools on our dApps portal. + +Right now, only the top 5 Runes are bridgeable, but more will follow as demand grows. + +You can already trade DOG, the top Bitcoin Rune, on: + +* Remus +* Layer Akira +* AVNU + +And yep, DOG can also be used as a gas token on Starknet via AVNU’s paymaster. + +You can see the full lineup of Runes available on Starknet in this dashboard. + +Also, StarkWare dropped a cool new tool called Broly—an open-source, trust-minimized Bitcoin inscription tool you can use straight from a Starknet crypto wallet. It’s still a proof of concept, but shows what’s possible for devs who want to build creative new stuff. + +**So what’s coming up next?** + +* Starknet will integrate with Xverse, the top Bitcoin wallet. That means easy switching between Bitcoin and Starknet. +* LBTC (Bitcoin LST) is coming to Starknet via Lombard. +* Thanks to Lightning and Square, Braavos users will soon be able to make real-world Bitcoin payments at terminals all over the U.S. + +## **S-two: The Fastest Prover Ever Is Live** + +Say hello to S-two—the world’s fastest prover. It’s 100x faster than the current one and is set to roll out across Starknet in about a few months. + +This upgrade means cheaper and faster proofs for all Starknet-based chains. It even opens the door for client-side proving on everyday devices. Paradex is jumping in first, using it to offer privacy-preserving trades. + +Across all benchmarks, S-two wins. Period. + +## **Starknet Becomes the First Real Stage 1 ZK Rollup** + +Starknet just became the first rollup to hit full Stage 1 status. + +Let’s break it down: + +* **Stage 0:** Centralized, but Ethereum can verify system state. +* **Stage 1:** No central operators, real smart contracts, real proofs, diverse security council. You can exit the system without needing permission. +* **Stage 2:** Basically Ethereum-level decentralization. A 30-day exit window for users in case of bad upgrades. The council only steps in under on-chain proven emergencies. + +Next big goals: + +* Hit Stage 2 +* Roll out Staking Phases 2 and 3 +* Final Phase 4 lands in early 2026, fully decentralizing the sequencer and prover + +## + +## **Starknet Ecosystem Updates** + +### **Extended DEX Is Migrating from StarkEx to Starknet L2** + +Big June news: Extended is (hopefully) launching on Starknet on July 2025. + +This Perp DEX is no joke—it already delivers a Hyperliquid-style experience: + +* up to 100x leverage +* Markets for crypto, gold, EUR, Brent, S&P 500, Nasdaq +* LP community vault yielding APR in USDC +* A live XP campaign (Season 1) + +And soon, all of this will run directly on Starknet. + +### + +### **Social Login & EVM Wallets** + +Cartridge just rolled out social login. You can now set up a Starknet wallet using your Discord account. More login options are coming. + +Also, you can now use MetaMask, Rabby, Phantom, and other EVM wallets to access Starknet via Cartridge Controller. + +Bonus: Rosettanet, a project aiming to bring full EVM wallet compatibility to Starknet, is expected to go live by July. + +### **Opus Staking Just Got a Yield Upgrade** + +Opus has integrated U.S. Treasury yields (T-Bills) into its staking system. That’s a first on Starknet. + +Here’s how it works: + +* Provide liquidity in the CASH/USDC pool on Ekubo +* Stake your LP token on Opus +* With it, you can earn:: + +* 75% of protocol revenue +* Extra yield from T-Bills +* swap fees from the USDC/CASH pool + +All powered by CASH—the only native stablecoin on Starknet. + +### + +### **Spend Starknet Assets IRL… for Free** + +Argent just launched its new Lite Card: + +* Free to use +* Self-custodial +* 0.5% cashback +* Spend USDC held on Starknet anywhere Mastercard is accepted + +Also, Cavos is working on a virtual card to let you do the same. + +### + +### **3 New Games Just Dropped** + +Starknet’s gaming ecosystem is booming with 3 new games live on Mainnet:: + +* **Eternum****:** Onchain Civilization-style game with AI agents and a $50K prize pool +* **Pistols****:** 1v1 onchain dueling game +* **Crimson Fate:** Fully onchain rogue-like + +The gaming ecosystem is becoming too vast to track? Cartridge Arcade has your back—it’s the hub for all Dojo-powered games. Find games, player profiles, leaderboards, and more. + +### + +### **Starknet Appchains: Full Steam Ahead** + +Three new projects are building with Starknet’s SN Stack: + +* **StarkPay:** Private payments +* **Forge Agent:** AI agent marketplace +* **Eara:** RWA trading infrastructure for Europe + +They’re part of the Karnot accelerator, which recently hit 7,000 TPS on Ethereum with SN Stack. And yes—it’s designed to go even bigger. + +Paradex, Starknet’s first live appchain, also tweaked its tokenomics: + +* Paradigm’s 13.4% allocation now unlocks on a linear, performance-based schedule +* 85% of the codebase has been audited by Cairo Audit + +## + +## **Alpha Zone: New Launches in May** + +Here’s what went live on Mainnet: + +* Eternum S1 +* Stormbit (99% LTV, no liquidation lending) +* Pistols +* Forge Yields +* Copperx +* Wolf Nation +* Curvy +* Crimson Fate +* OnChainGM (say “gm” onchain for 0.5 STRK) + +And on Testnet: + +* defi.space: Arena for AI agents +* Trivex: Perp DEX + analytics + +Also spotted a new builder: + +* Uncap: Bitcoin-backed stablecoin inspired by Liquity + +In summary, June marked a period of comprehensive advancement for the Starknet ecosystem. The network significantly deepened its integration with Bitcoin by making assets like Runes and USDC natively tradable and bridgeable on Starknet. Core infrastructure saw a major leap forward with the introduction of S-two, a prover promising to be 100x faster, which will lead to cheaper and quicker transactions. This technological progress was complemented by a critical milestone in network maturity, as Starknet became the first to achieve Stage 1 ZK-Rollup status, signaling a concrete move towards greater decentralization. This foundation spurred a wave of growth across the ecosystem, including the migration of established DEXs, a surge in new on-chain games, and the launch of innovative financial products and wallet features that simplify everything from staking to real-world spending. + +***Disclaimer:*** + +*This blog post was written by 0xLyskey, a community member. The views, thoughts, and opinions expressed in the text belong solely to the author.* + +*This content is provided for informational purposes only and should not be construed as financial, investment, or any other form of advice. Readers are solely responsible for their own decisions and are strongly encouraged to conduct their own research and consult with a qualified professional before making any financial commitments. Stay safe and do your own research.* + +--- +Sources: + - https://www.starknet.io/blog/starknet-june-ecosystem-recap/ +--- + +## Starknet’s June recap | Starknet + +Home  /  Blog + +A deep dive into June's major upgrades in speed, decentralization, and Bitcoin integration + +Written by: Lyskey + +Jun 30, 2025 · 6 min read + +Welcome to the 23rd edition of the monthly recap, your go-to source for the most significant updates and developments within the Starknet ecosystem. + +### + +## **Key Highlights of the Month** + +### **Bitcoin on Starknet, Starknet on Bitcoin** + +The synergy between Bitcoin and Starknet continues to evolve with exciting new developments. + +The leading Bitcoin memecoin by market capitalization, DOG, is now deeply woven into the Starknet ecosystem. It is now available for trading on platforms such as **AVNU**, **Remus**, **Layer Akira**, and **Fibrous**. You can also use DOG for lending and borrowing on **Vesu** and trade it or use it as an LP token on **Ekubo**, which now includes DeFi Spring incentives for DOG. This integration means you can bridge, trade, and earn yield with your Runes, expanding their utility on Starknet. + +A new variant of BTC, **tBTC**, is now directly mintable on Starknet, making it available for integration and use across Starknet’s DeFi landscape. + +Furthermore, **Layerswap** has introduced direct bridging from Bitcoin, a feature that, besides Ethereum, is exclusively offered for Starknet. + +Looking ahead, **Bitcoin staking** is anticipated to launch on Starknet in the third quarter of 2025, and more details have been unveiled. The key aspects include: + +* BTC holders will have the ability to stake their BTC on Starknet. +* Bitcoin will contribute to Starknet’s economic security, accounting for up to 25% of the validator staking power. +* STRK will continue to be the primary staking asset, representing over 75% of validator power. +* A mechanism to align the interests of BTC and STRK holders will be implemented. +* The target for this launch is Q3 2025. + +Regarding **Asset Runes**, USDC bridging between Bitcoin and Starknet is now operational on **StarkGate**. You can create USDC Runes on Bitcoin and redeem them on Starknet at any time. Additionally, USDC can now be traded directly on Bitcoin via the **Magic Eden** aggregator. + +### **Starknet’s Continuous Improvement** + +The ecosystem is advancing at a rapid pace, with the final elements of the current roadmap expected to be completed in the coming weeks. + +A new minor but crucial version, **Starknet v0.13.6**, was deployed on Testnet on June 30 and is scheduled for Mainnet on July 8. This update is essential as it sets the stage for the integration of **S-two**, StarkWare’s next-generation prover. The S-two MVP promises to: + +* Reduce proving time for 2B L2 gas blocks from 24 minutes to under 3 minutes. +* Decrease proving costs by at least half. + +It’s important to note that S-two is not activated with v0.13.6; this version merely prepares the network for its future implementation. + +The subsequent major release, **Starknet v0.14.0**, is planned for Mainnet in mid-August. This version will introduce: + +* A new sequencer architecture featuring four sequencers operating in rotation, coordinated by a Tendermint-like consensus, marking a significant move towards decentralization. +* Pre-confirmations, which will lower the perceived finality for most transactions to approximately 0.5 seconds from the current ~2 seconds. +* The deprecation of legacy transactions, making v3 transactions (RPC 0.8) the standard. While STRK will be the sole native gas token, users can still pay fees with other tokens using Paymasters from **AVNU** and **Cartridge**. +* A mempool and EIP-1559, where transaction priority is determined by fees rather than on a first-in, first-out basis. This also paves the way for burning STRK from fees, similar to Ethereum’s mechanism. +* A reduction in block time from 30 seconds to 6 seconds. + +Developers should review this version thoroughly due to the introduction of breaking changes. + +#### + +### **Enhanced Performance, UX/DevX, and Decentralization** + +Staking v2 has been launched on Mainnet, bringing improvements to the economics and transparency of validators. The two main changes are: + +* **Block attestation**: Validators are now required to attest to randomly selected blocks during each epoch. +* **Commission adjustments**: Validators have the ability to change their commission rates under specific, strict conditions. + +With the completion of phase 2, the final staking architecture is now just two versions away. + +As of June 30, the staking metrics showed **310 million STRK** staked and **77 out of 121 validators** actively attesting blocks. + +In addition to Staking v2, StarkWare has revealed its plans to participate in STRK staking through two methods: + +* Delegating millions of STRK to eligible validators based on certain conditions. Applications for those interested in receiving delegations from StarkWare are now open. The aim is to enhance decentralization by supporting smaller validators. +* Operating its own validator, with its stake capped at 10% of the total STRK staked. For instance, if 1 billion STRK is staked in total, StarkWare’s validator can stake a maximum of 100 million STRK. + +On a related note, **Figment** now provides support for STRK staking, enabling institutions to delegate their STRK to Figment. + +### + +## **Starknet Ecosystem Updates** + +### **A Next-Generation Perpetual DEX is Coming to Starknet** + +**Extended** has revealed its vision and plans for migrating to Starknet. The migration process is designed to be seamless for users and will commence in the first half of August. The launch of Extended is considered one of the most significant DeFi events on Starknet since Vesu, offering: + +* Perpetual trading on over 50 assets with leverage up to 100x. +* Trading pairs for cryptocurrencies as well as traditional financial markets like Gold, Nasdaq, USD, and EUR. +* A community vault with an approximate yield of 22% in USDC. +* Development by a team with strong credentials, including former Revolut employees. +* Comprehensive EVM wallet support, including MetaMask, Rabby, and Phantom. + +All of this will be accessible directly on Starknet. + +### **The Wolf Pack League is Now Open to All** + +The **Wolf Pack League** has officially launched, creating a program that allows anyone, from content creators to developers and designers, to contribute to Starknet’s expansion and earn rewards. Projects can also post their own bounties. This initiative creates a win-win situation for the growth of Starknet: + +* Projects can instantly connect with Starknet’s community of creators and developers to accelerate their growth. +* Creators and developers have an open platform to find opportunities that match their skills and get compensated for their work. +* How to get started as a user +* How to create a bounty as a project + +### **Develop on Starknet Without Writing Cairo** + +**Cairo Coder** is now live, a tool that allows you to generate Cairo smart contracts or programs directly within Cursor. These generated components are fully compatible with the entire Starknet development stack and are consistently kept up-to-date. In essence, you can now build on Starknet without needing to write any Cairo code yourself. This tool empowers anyone to develop and launch projects on the network. + +* Example of what you can build with it +* Here’s how to get started + +#### + +### **Endur Points Program & Airdrop** + +**Endur**, the liquid staking protocol on Starknet, has launched its points program. You can now accumulate daily points simply by holding or utilizing xSTRK in various DeFi applications. In addition to the points you may have already earned, early users of Endur will receive an airdrop of all the revenue the protocol has generated so far. You can check your eligibility here. + +### **Ecosystem Quick Bites** + +* **Argent X** has rebranded to **Ready**. +* **STRKfarm** has changed its name to **Troves**. +* AAVE, POL, UNI, and ENA can now be traded on Starknet through **Layer Akira**. +* **Blob Arena** had its full launch during a major live sports event, reaching an audience of thousands. +* **zkLend** is shutting down, with both its Money Market and liquid staking services being discontinued. + +#### + +### **Alpha Zone** + +Three new projects went live on Starknet Mainnet this month: + +* **Atemu**, a card game built on Starknet. +* **Lutte Arcade**, a battler set in the lootverse. +* **Karat**, a new NFT collection. + +### + +### + +### + +## **Top Content of the Month** + +### **Ekubo: The AMM Endgame** + +This is the most comprehensive article available on **Ekubo**. It covers everything you need to know in a single place, including what makes it unique, its tokenomics, the team behind it, and its DAO. You can read it here. + +### **BTCfi on Starknet is Real** + +A complete summary of what you can currently do with Bitcoin on Starknet and what is planned for the future. Find the full recap here. + +### **S-two in Action** + +Discover how **S-two**, StarkWare’s next-generation prover, is enabling partners to develop groundbreaking new use cases: + +* **Giza** is using it to make AI actions provable. +* **Nexus** is leveraging it for provable computation with Rust, C, and RISC-V. + +When it comes to performance, S-two has significantly surpassed its competitors. See more here. + +### + +*Disclaimer: This blog post was written by 0xLyskey,, a community member. The views, thoughts, and opinions expressed in the text belong solely to the author. This content is provided for informational purposes only and should not be construed as financial, investment, or any other form of advice. Readers are solely responsible for their own decisions and are strongly encouraged to conduct their own research. Stay safe and do your own research.* + +--- +Sources: + - https://www.starknet.io/blog/starknet-july-ecosystem-recap/ +--- + +## Starknet’s July recap | Starknet + +Home  /  Blog + +Dive into July's major ecosystem updates, featuring Starknet v0.14.0 'Grinta,' new staking programs, and key project integrations. + +Written by: Lyskey + +Jul 31, 2025 · 6 min read + +Updated Aug 17, 2025 + +Welcome to the 24th installment of my monthly summary, where I share the most significant updates and progress within the Starknet ecosystem! + +## Important news of the month + +## Grinta is coming this month + +Starknet v0.14.0, which has been codenamed Grinta, is set to launch on Mainnet on August 18. This upgrade, already available on Testnet, represents a significant step forward for both decentralization and user experience. + +It introduces 6 major enhancements: + +* **Decentralized sequencer architecture:** Beginning with this version, the network will utilize three sequencers operating with Tendermint consensus and a 1/2 threshold. This is the initial move toward a fully decentralized sequencing model on Starknet. It’s also worth noting that Juno is actively working to become a Starknet sequencer by using Nethermind’s Go-based custom Tendermint implementation. +* **Pre-confirmations:** A new, intermediate transaction status is being introduced, featuring a latency of about 0.5 seconds. This will make most transactions feel almost instantaneous, reducing the perceived execution time from approximately 2 seconds to a mere 500 milliseconds. +* **Block times reduced:** The time to create a new block will be cut from 30 seconds down to 4-6 seconds. Starknet has plans to decrease this even more later in the year, particularly with the help of Cairo-Native. +* **Fee market for l2\_gas:** Taking inspiration from Ethereum’s EIP-1559, this update brings in a system of base fees and tips. While base fees will not be burned in v0.14.0, this feature is planned for a future release (though no specific date has been set). +* **Mempool upgrade:** The previous First-In, First-Out (FIFO) system is being replaced. Transactions will now be prioritized based on the tip amount, meaning those who pay more will have their transactions processed first. +* **V3 transactions only:** Henceforth, the network will only support v3 transactions, which exclusively use STRK for gas fees. To pay fees with other tokens, you will need to use a paymaster service like the one offered by AVNU. + +Learn more in the dedicated SNIP and pre-release notes. + +Regarding the future, the StarkWare team is currently gathering feedback for the next roadmap. This is an excellent opportunity to let your voice be heard. + +## STRK staking heats up + +Following the recent release of STRK staking v2, both StarkWare and the Starknet Foundation are intensifying their efforts to support the decentralization of staking on Starknet by launching their own delegation programs. The objective is to assist new validators in joining the network and to help smaller validators achieve profitability by delegating a portion of their STRK to these external participants. + +StarkWare has already finished its initial delegation round, allocating 75M STRK among chosen validators. Additionally, they have launched their own validator, staking 30M STRK to it. The second round is accepting applications until August 11, so if you wish to receive a delegation from StarkWare, you should **apply now**. + +The Starknet Foundation’s delegation program is also underway, providing a 1:1 match of up to 5M STRK for validators who meet the criteria. The results of this program will be made public by August 31. + +Important to note: You are permitted to apply for both programs and could potentially receive a delegation from each one. So, don’t hesitate to apply to both! + +With approximately 430M STRK staked, delegation programs active, and Grinta on the horizon, decentralization is not just on its way—it’s actively unfolding. + +## Web3 UX, finally usable for everyone + +Starknet is consistently advancing towards a user experience on par with Web2, without making compromises. Here are the key developments from this month: + +* The **Starknet Paymaster by AVNU** is now operational. It is fully open-source, audited, and permissionless, enabling anyone to sponsor or abstract user gas fees in less than five minutes. +* **Ready Mobile wallet** is already using this technology to provide a completely gasless user experience, meaning users no longer need to hold or be concerned about gas tokens. +* **Cavos** has introduced **Aegis-v1**, a new offering that lets projects facilitate smooth onboarding with invisible wallets that are powered by social logins (such as Apple and Google), along with a totally gas-free experience. + +Widespread adoption is not possible without a user experience that is both seamless and easy to grasp. Starknet is committed to delivering just that. + +## Starknet connects to 140+ chains + +Hyperlane has formally incorporated Starknet into its interoperability stack. This allows developers to effortlessly deploy custom bridges that link Starknet with a network of up to 140 chains. + +Developers are already taking advantage of this new capability: + +* **Daydreams** has launched a Solana <> Starknet bridge for its DREAMS token. +* **Forge Yields** is developing cross-chain yield products utilizing this technology. + +## Starknet Ecosystem Update + +### Starknet now accessible on the leading Bitcoin wallet + +Xverse now includes support for Starknet Mainnet in both its browser extension and mobile application. This integration means Bitcoin users can now access Starknet by simply switching networks within the user interface and can manage their assets directly on Starknet. + +This marks only the first phase of their Starknet integration. The next stage involves integrating the Xverse wallet into various Starknet applications, spanning both DeFi and gaming. + +## Real-world BTC use case in El Salvador + +Representatives from StarkWare and the Starknet Foundation visited El Salvador to connect with Bitcoin developers who are addressing tangible, real-world issues. A central question was: How can Starknet help them achieve their goals? + +One of the resulting solutions is a Bitcoin ATM, now live and fully powered by Starknet. This ATM allows users to buy BTC directly with cash (both bills and coins), store their funds on Starknet, and benefit from an experience that is smoother than using the Lightning Network. Better yet, this provides them with a direct entry point into Starknet’s DeFi ecosystem. It is anticipated that more projects stemming from the El Salvador initiative will join Starknet in the near future. + +## Paradex steps back to go even further + +Paradex is prolonging its Season 2 XP campaign for up to an additional six months, thereby postponing the DIME token generation event (TGE), and they have a solid reason for this decision. The team aims to first release their complete suite of products: + +* Spot market +* Pre-market +* Yield-bearing synthetic dollars (XUSD) +* The highly anticipated Money Badgers campaign + +On another note, the cap for the Gigavault has been raised to $50M, allowing LPers to now enter. Since its launch, the vault has been yielding an APR of around 18% in USDC. + +## StarkWare now has skin in the DeFi game + +StarkWare has finalized an over-the-counter (OTC) agreement with the AI agent framework project, DAYDREAMS, acquiring a stake in the DREAMS token supply. Furthermore, StarkWare is now contributing to the project’s growth by providing liquidity to the DREAMS/STRK pair on the Ekubo protocol. + +## JediSwap shuts down + +JediSwap is officially ceasing its operations. The project’s frontend is now deprecated. If you have liquidity remaining on the platform, please be aware that you can still perform manual withdrawals directly from the smart contracts. + +## OpenZeppelin Contracts MCP now live on Starknet + +In addition to Cairo Coder, developers (and even non-developers) can now leverage OpenZeppelin Contracts MCP to construct and deploy dApps in just three simple steps: + +1. Prompt an idea +2. Generate the contracts +3. Deploy the dApp + +Building on Starknet has never been more straightforward. + +### **Gaming ecosystem shipping non stop** + +Starknet continues to be a leader in the onchain gaming space, and this month has seen another wave of releases: + +* **Realms** (formerly Eternum) has introduced **Blitz**, a new, fast-paced 2-hour war mode. +* A new game has been launched, developed by  **Starknet Brother x Octo Gaming**. +* **Dante Horton**, a veteran of the gaming industry, has joined **Grug’s Lair** as an advisor. +* The winners of the recent **Grug Game Jam** (a vibe coding hackathon) have been revealed. + +## Alpha Zone + +This month, two new projects have launched on Starknet Mainnet: + +* **Caddy Finance**, a BTC vault designed to generate yield for Bitcoin holders. +* **Bro Jump**, a game created in collaboration with the well-known Starknet Brother memecoin. + +I’ve also identified five new projects that are currently under development on Starknet: + +* **Brove**, a central hub designed to simplify the use of BTC in various DeFi and social applications. +* **Panenka FC**, a fantasy football game. +* **SharkX Trading**, the first fully onchain proprietary trading firm. +* **Numo**, a platform for modular BTC vaults. +* **Fortichain**, an infrastructure project with a strong focus on security. + +## Some of the Best Content of the Month + +## Starknet Q2 Recap: Setting the stage for H2 2025 + +Starknet ships a substantial amount of updates every month. However, when you take a broader view and look at an entire quarter, the level of progress is truly remarkable. Get up to speed on all the developments from Q2, including protocol upgrades, decentralization efforts, ecosystem growth, BTCfi, and a look at what lies ahead. + +## Paradex: the better-than-CEX DEX + +Why opt for a centralized exchange when you can enjoy speed, a great user experience, and self-custody all in one place? Paradex serves as Starknet’s native appchain for trading, and it is already surpassing the typical CEX experience >> Learn how. + +*Disclaimer: This blog post was written by 0xLyskey,, a community member. The views, thoughts, and opinions expressed in the text belong solely to the author. This content is provided for informational purposes only and should not be construed as financial, investment, or any other form of advice. Readers are solely responsible for their own decisions and are strongly encouraged to conduct their own research. Stay safe and do your own research.* + +--- +Sources: + - https://www.starknet.io/blog/blurb-on-liquidity/ +--- + +## Blurb on Liquidity: Understanding DeFi Market Dynamics | Starknet + +Home  /  Blog + +Written By: Ilia Volokh + +Aug 10, 2025 · 12 min read + +This post attempts to organize a basic understanding of liquidity, oriented at DeFi. We’ll define liquidity and its key metrics, and analyze it for constant-product AMMs. Then we’ll touch on impermanent loss and end with a brief overview of concentrated liquidity. + +# Liquidity + +Liquidity is a property of markets, crucial for capital efficiency. Folklore intuition can be summed up in one line: + +> A market is liquid if it can quickly execute trades with minimal price changes. + +For example, major stock exchanges are liquid markets for commonly traded stocks. + +It is typical to abuse terminology and say an asset is liquid, meaning “this asset is quickly convertible into money with minimal loss”. Formally, this statement asserts the liquidity of an implicit market between the asset and money. For examples, a house is an illiquid asset because it takes a while both to discover the market price and to sell it at that price. + +One sometimes encounters the term “funding liquidity”, referring to the ease of obtaining credit (i.e., borrowing). Thus an asset has high funding liquidity if it can serve as collateral for money at a good rate. + +For some history see e.g. this stackexchange answer. + +Liquidity is measurable by a few key metrics: + +| Metric | Meaning | Consequence | Cause | +| --- | --- | --- | --- | +| Spread | Lowest sell price (best ask) minus highest buy price (best bid). | Wide spread → high cost to initiate trade | Insufficient market-making | +| Depth | What asset amount can be traded within some price range? | Shallow depth → volatility | Insufficient supply | +| Price impact | How does my trade impact the current market state? | High price impact → I get less | App-level: depth & spread | +| Slippage | What I expected when placing my trade vs what I got when it executed. | High slippage → I get less | Core-level: market state discrepancy between simulation & execution, e.g. due to competition, latency, MEV | + +Spread is a threshold cost which dominates small trades. Larger trades begin to consume depth, which outweighs the initial spread. + +Before diving a bit deeper, we record a common unit of measurement in finance: + +**Definition.** A basis point (plural bps) is a hundredth of a percent $0.01\%=\frac{1}{10,000}$. + +## Spread + +Assuming the market price is within spread interval, a taker must pay a premium to immediately initiate a trade. Wider spread → higher premium. + +[highest bid,lowest ask] + +A narrow spread thus increases capital efficiency, especially for small trades. A spread of 10 bps means the highest bid and lowest ask differ by $0.10\%$. + +## Depth + +High depth around an exchange rate leads to price stability: even large trades will not cause volatility. The statement “there’s 10K USD of BTC buy-side depth per bp at the current price” means you can buy 10K USD-worth of BTC and incur a price change of at most one basis point, i.e $0.01\%$. + +The depth of liquidity in a price interval should be thought of as the supply of capital deployed there. High depth at exorbitantly high/low prices is wasted capital. We’ll unpack this later for constant-product AMMs. + +Depth is also crucial for stable capital-efficient loan markets because it ensures liquidations are profitable to liquidators. We illustrate the opposite extreme: how shallow depth triggers a liquidation death spiral. The loan market in question is borrowing USD against BTC collateral. + +* Suppose Alice loaned 1M USD to Bob against 10 BTC. Suppose Bob defaults, so that Alice seizes 10 BTC. Now suppose Alice wishes to liquidate the loan i.e. sell the BTC for USD. If the BTC/USD market in question has shallow liquidity, the exchange rate would dip against Alice: she may sell 1 BTC at a good price, but any larger amount would sell at an increasing loss to her. In case of an over-collateralized loan, Alice can make a quick profit even if she sells some of her BTC underpriced. Such a sale would lower the BTC/USD exchange rate against BTC, potentially triggering more liquidations. +* Depth is the dampener of liquidations, defending against chain-reactions and death spirals. + +## Price impact + +Products sold in stores typically have posted prices, which trivialize economic calculation. The naive approach to buying some amount of an asset would be to multiply its market price-per-unit by the amount. + +If the market price is a 1 USD/unit, I naively expect 100 USD to buy me 100 units. *Price impact* is any deviation from this expected outcome. Such deviations are deterministic in the current market state, and determined entirely by trade size, spread, and depth. Price impact can be mitigated at the application level, e.g. via aggregators and routers which traverse multiple markets. + +## Slippage + +Even if I have perfect knowledge of the market mechanism (e.g. AMM curve) and its current state, I do not know the future market state at the execution of my order. Despite my ability to perfectly simulate my trade, I cannot predict the market conditions at execution: reality can differ from my expectations, resulting in *slippage*. Such slippage can be honest, e.g. competitors pay higher priority fees and overtake me, or manipulative, e.g. sequencers manipulating ordering. + +# Market-makers + +Markets are not in a constant state of equilibrium, and organic activity (or lack thereof) can result in occasional wide spreads. + +1. Buyers and sellers need not show up together. There can be waves of one-sided demand, in terms of both time and volume. +2. Price discovery takes time: buyers would initially post low bids and sellers would initially post high asks. +3. Liquidity may not arise organically, due to wide spreads or shallow depth. + +Market makers (henceforth MMs) streamline market operations by providing supply & demand counterparties and optimizing price discovery. + +## Order-book market-makers + +In order-book markets, MMs act by posting trades that bring the market closer to equilibrium. The naive business model is simple: manufacture spread and profit off it. Specifically, MMs manufacture spread by maintaining a gap between their highest bids and lowest asks. They aim for a narrow spread when competition is high and risk is low, and conversely. Let’s make this a bit more explicit. Assume Alice and Bob are competing MMs. If Alice quotes (posts orders) slightly tighter than Bob, then her orders are more attractive to traders, and they’ll get executed first. This is obviously good if she profits, but a volatile market may actually cause tight spread to incur losses. + +Although MMs profit off of wider spread, a competitive market also incentivizes them to provide *depth* around their *tightest* quotes. Indeed, once demand depletes Alice’s tightest quotes, she no longer has any competitive advantage over Bob. The more depth she provides, the more orders she will be able to capture from Bob at her tighter spread (despite profiting less per unit exchanged). + +To summarize, order-book market-makers are precisely liquidity providers! + +## AMMs; impermanent loss + +An AMM is an implementation of a market that: + +1. Automatically computes exchange rates based on its state. +2. Automatically distributes supply across the exchange-rate curve to create liquidity. + +Since AMMs automatically manage capital, the only *required* making is the deployment of capital. It so happens that AMM terminology refers to these capitalists as liquidity providers. As we shall see below, more refined AMM designs actually involve makers who choose where to deploy capital, i.e. where to create depth. In this sense, they are indeed liquidity providers as opposed to “mere capitalists”. + +Before continuing, we’ll define an important concept that is often overcomplicated by only looking at examples. + +**Definition.** A pair (LP position, initial deposit) is at *impermanent loss* if the current the value of the LP position is lower than the current value of the initial deposit (i.e. at current exchange rates). + +To emphasize – impermanent loss is only defined with respect to an initial deposit; it’s not an intrinsic property of an LP position. Put succinctly, impermanent loss is the opportunity cost of being an LP instead of holding on to the capital in a wallet. This opportunity cost if offset by expected profit from trading fees. + +Impermanent loss is so-called because it may be transient. It is caused by arbitrage traders reacting to market shifts: + +1. The market outside the AMM shifts, affecting the market exchange rate between the AMM assets. +2. Arbitrage traders buy the appreciated asset from the AMM for cheaper than on the external market. +3. The AMM supply of the appreciated asset decreases until the AMM discovers market price. +4. If an LP redeems their share of each asset, they end up with a smaller amount of the appreciated asset than they deposited, but a larger amount of the depreciated asset. +5. The current value of the redeemed LP position is lower than the current value of the original deposit. + +Risk of impermanent loss vanishes once AMM exchange rates return to the neighborhood of the initial deposit. For this reason, it is customary for volatile pair LPs to charge higher fees. + +The above formulation should make it clear there is no “impermanent gain” – arbitrage traders buy whichever asset is undervalued by the AMM. + +# Worked example: constant-product AMMs + +We now illustrate the abstract nonsense above in the setting of a constant-product AMM. We start out **without fees**, and address them later. + +## Basics + +Fix two assets $X,Y$ and denote by $x,y$ their respective supplies. The AMM curve is $xy=k$ for some constant $k$. Evidently the curve is symmetric in $x,y$. As a function of $x$, we see $y=\tfrac kx$ is not only monotone decreasing but also *subadditive*, which enforces diminishing marginal utility. Conceptually, this is the only required property of an AMM curve. In our constant-product case, marginal diminution is visualized by the hyperbola curve: As the supply $x$ grows, a fixed change of supply $\Delta x$ causes a diminishing change of supply $\Delta y$. + +Let us quantify supply changes. Suppose the present state of AMM supply is $x,y$. How does a change in supply $\Delta x$ affect the supply of $Y$? By definition, the next state of the AMM supply is $x+\Delta x, y+\Delta y$, so the invariant constraint gives us + +Hence + +Thus we see how $\Delta y$ inversely depends on the initial supply $x$. + +The exchange rate (price) charged by the AMM is just the ratio of supplies. The fraction $\frac{y}{x}$ is the supply of $Y$ fitting into a unit supply of $X$. That is, the $Y$-price of a unit of $X$. Price change is easily computable: + +Note the $Y$-price of a unit of $X$ obeys an inverse square law w.r.t to the supply of $X$: price decays quadratically as supply grows. This super-linear decay also exhibits diminishing marginal utility. + +Prices are not encoded by the AMM equation, but rather discovered by the market. The equation merely constrains the supplies to satisfy diminishing marginal utility, which is necessary for price discovery. (Play around with a constant-sum equation and see how the resulting market is severely misbehaved. Hint: the exchange ratio must be 1:1, so no diminishing marginal utility and therefore no price discovery and the pool is easy to drain.) + +## Depth analysis + +In this section we’ll quantitatively analyze the depth in constant-product AMMs. Our goal is to answer questions like “what percent of the supply is employed for trading within a given price range”. + +We can express supply $x$ as a function of the $Y$-price per unit of $X$: $p=\frac yx$. + +Note a larger constant $k$ means more depth: the market sustains a larger supply of $X$ at a given price. + +By definition, depth is the supply change required to move between given prices. + +Depth is nonnegative iff $p\_1\leq p\_2$: supply decreases iff price increases (in this AMM). Evidently depth is antisymmetric, so the price interval determines a unique number – the absolute value of the associated depth. Note also how depth scales with the interval: + +> Constant-product AMM depth decays slowly as $\frac1\surd$. + +Equipped with the depth formula, we can analyze the capital efficiency of constant-product AMMs. Specifically, we’ll analyze how the constant product curve causes supply to be inefficiently allocated to price bands with low trading activity. + +### Depth on the tail + +Assume a current supply of $x\_0$ at a price-per-unit of $p\_0$. This supply is distributed over the price range $[p\_0,\infty)$ precisely according to depth. + +* A divergent increasing sequence of prices $p\_0 The partition of total current supply by depth specifies the amount of current supply allocated to each price band. + +How much supply is “wasted” on exorbitantly high prices? Consider a $\overbrace{\text{USDC}}^Y/\overbrace{\text{ETH}}^X$ pool with $k=10^{10}$. As of July 2025, 1 ETH ≈ 3000 USD, so $p\_0=3000$ whence $x\_0=\sqrt\frac{10^{10}}{3000}\approx 1825$. A high USD-price of ETH is denoted $p\_\top$. The depth formula gives + +Some example computations show the extreme capital inefficiency of the constant-product curve. + +### + +### Depth in general + +How to interpret $D\_X(p\_1\to p\_2)$ if the current price $p\_\text{now}$ satisfies $p\_\text{now}>p\_1$? In this case, reaching $p\_1$ would require an increase in supply, so we can’t use the partition trick above. Or can we? Math shows the way. The equation + +interprets the LHS as the amount of supply required for a price increase $p\_1\nearrow p\_\text{now}$, plus the (familiar) depth starting from the current price. + +### Depth concentration + +We can write an explicit formula for the relative depth concentration in a price band within a larger band $[p\_1,p\_2]\subset [p\_\perp,p\_\top]$, notably independent of the constant $k$. + +Let’s analyze the capital efficiency of a constant-product AMM for a **stable pair** USDC/USDT. by looking at the relative concentration of a bp interval vs a 1% interval (factor of 100) + +So assuming the entire market lives within a 10% band, merely 10% of capital is allocated to trading within a %1 band, and merely 1% is allocated to trading within a basis point! + +## Impermanent loss + +Consider an ETH/USDC pool with initial supply of 100 ETH and 100K USDC, so initial ETH price is 1000 USDC and the constant is $k=10^7$. Now assume ETH price doubled to 2000 USD on the outside. Traders flock in to buy the underpriced ETH from the AMM. We compute the ETH reserves at the end of price discovery, when the AMM price has stabilized at 2000 USDC per ETH: + +Suppose Alice initially owned 10% of the pool. + +* Her initial deposit was 10 ETH and 10K USDC. Current value = 30,000 USD. +* Her current LP position is 7.071 ETH and 14,142 USDC. Value $\approx$ 28,284 USD. + +## What about fees? + +Percentage fees are crucial for LP revenue. They slightly increase price impact, especially for larger trades. + +# Concentrated liquidity + +Classically, there is a clear distinction between capitalists, who passively provide capital, and those who actively employ capital (often delegated to them). In DeFi terminology, capitalists are the *passive* liquidity providers. However, *active* liquidity providers are superior market makers, who have strong potential to enhance capital efficiency. We illustrate this with a case study: Uniswap v2 vs Uniswap v3. + +Uniswap v2 is a constant-product AMM. LP UX is roughly: choose pair → deposit assets → receive LP token → earn fees → exit. LPs must supply equal value of both tokens (to preserve pool price). Since LP positioned are fully determined by deposited capital, LP tokens are just fungible ERC-20 tokens. + +Uniswap v3 is a “piecewise-constant-product” AMM. LP UX is roughly: choose pair → choose fee tier → choose price range → deposit assets → receive LP token → earn fees → reposition/exit. Each pool partitions the allowed price range via *ticks*, via which LPs can specify their desired price bands for deploying capital (adding depth). Due to the added complexity of the liquidity position, LP tokens are (currently) NFTs, encoding more than the ERC-20 standard allows. + +The ability to concentrate capital in a chosen price range precisely means LPs are free to choose where to provide depth. Let’s illustrate how beneficial this design is for capital efficiency by examining a stable pair, e.g. USDC/USDT (I wonder how well this will age). The vast majority of LPs will choose to provide depth in a narrow band about the 1:1 rate, so liquidity will be deep in the center and shallow at de-pegged exchange rates. If Alice deposits in tick range $[t\_1,t\_3]$ and Bob deposits in $[t\_2,t\_4]$, both are active in $[t\_2,t\_3]$, and both provide liquidity to the constant-product AMM associated to this small interval. The locality of each piece in Uniswap v3 mitigates the slow $\frac1\surd$ decay of depth in constant-product AMMs to small intervals. + +Unfortunately the piecewise design has a significant drawback: it exacerbates the risk of impermanent loss. For example, assume Alice concentrates her capital at in the range $[2900,3100]$ USD per ETH. Suppose ETH begins tp appreciate with respect to USD in the outside market. As usual, arbitrage traders buy the strong asset (ETH) from the pool. However, since Alice concentrated all her capital in this narrow range, if ETH appreciates beyond the interval, her entire initial deposit of ETH would be depleted and exchange for USD due to arbitrage. In other words, the narrow price range makes Alice more susceptible to impermanent loss. As usual, if the price moves back in range, the impermanent loss vanishes, and Alice can continue her plans for world domination. + +In a sense, piecewise-constant-product AMMs interpolate between a constant-product AMM on one end, and an order-book in the other: liquidity providers act as market makers by choosing where to deploy capital. Concentrated liquidity assists price discovery due to aligned incentives: LPs earn trading fees when their deployed capital is used, so they naturally want to provide depth near market prices. Order-books still have some advantages: market-makers have room for more capital efficient strategies, and they’re not exposed to impermanent loss! + +The article was originally posted by Ilia on GitHub’s Unthoughts. + +--- +Sources: + - https://www.starknet.io/blog/moms-making-crypto-crystal-clear/ +--- + +## A Mother’s Day Masterclass: Moms Making Crypto Crystal Clear - The Clear Crypto Podcast | Episode 7 | Starknet + +Home  /  Blog + +Share this post: + +Aug 19, 2025 + +How do crypto’s toughest concepts become crystal clear? In this special Mother’s Day episode, host Nathan and co-host Gareth bring in four brilliant crypto moms to break it down. + +From Adi’s deep dive into blockchain bridging to Jenny’s insights on crypto crime, Katherine’s take on navigating the SEC and Blue’s guide to stablecoins, these experts make the complex simple. No jargon, just straight talk from moms mastering crypto and motherhood. Whether you’re new or a seasoned hodler, this one’s for you. Produced by Tonal Media. + +In the next few lines, we’ll summarize the special Mother’s Day episode of the Clear Crypto Podcast. Often, when someone wants a complex topic explained simply, they use the lazy phrase, “Explain it like you would to your mom.” This episode flips that tired cliché on its head. Instead, we hear from some of the sharpest minds in crypto—who also happen to be moms—as they explain the industry’s most intricate concepts to the rest of us. + +Hosted by Nathan Jeffay and Coin Telegraph’s Managing Editor, Gareth Jenkinson, this episode brings “no jargon, no hype, just straight talk.” We’ll dive into four crucial topics with four incredible experts: Adi Shildan Meidan StarkWare’s Product Manager, demystifies the world of crypto bridges; Jennie Levin breaks down crypto crime from her perspective as a former federal prosecutor; Katherine Kirkpatrick Bos gives us the inside scoop on the SEC; and Blue Macellari clarifies the essential role of stablecoins. Get ready to have these concepts explained with the clarity and precision that only a mom can provide. + +## Demystifying the Crypto Bridge with Adi + +Every blockchain, whether it’s Bitcoin, Ethereum, or Starknet, operates like its own self-contained island. It has its own rules, its own native currency, and its own community. But what happens when you want to move assets or information from one island to another? Imagine if your phone could only call people who used the same mobile carrier—it would be incredibly limiting. This is the problem that a crypto bridge solves. + +To help us understand this vital piece of infrastructure, the podcast welcomed Adi, a former professional dancer and choreographer who pivoted into the world of blockchain technology. As a mother to two young girls, Adi is an expert at breaking down complex movements into simple steps, a skill she now applies to explaining protocol architecture. + +## What is a Crypto Bridge? + +“A bridge is a way to move funds from one place to another,” Adi explains in the simplest terms. Just like a physical bridge connects two separate landmasses, a crypto bridge connects two separate blockchains, allowing users to transfer assets between them. Starknet, a leading Layer 2 scaling solution for Ethereum, relies on its own robust bridge, StarkGate, to allow users to move assets securely between the Ethereum mainnet (Layer 1) and the faster, cheaper Starknet environment (Layer 2). + +While there are several types of bridges, Adi focused on one of the most common and important models: the “lock-and-mint” or “burn-and-mint” mechanism. + +### How the “Burn and Mint” Model Works + +Let’s walk through the process step-by-step: + +1. **Locking the Asset:** Imagine you have an asset, let’s say 1 ETH, on the Ethereum blockchain (the “origin” chain) and you want to use it on another blockchain. To start the process, you send your 1 ETH to a specific smart contract on Ethereum that acts as the bridge’s vault. This contract “locks” your ETH. Adi uses a fantastic analogy: “It’s like when you’re in Monopoly and you are in jail… you can’t do anything with your funds.” Locking ensures that the original asset cannot be spent or moved while its equivalent exists on the other chain, preventing double-spending. +2. **Minting the Representation:** Once the bridge confirms your ETH is locked on the origin chain, it triggers a corresponding action on the destination chain. A new token, which is a wrapped or synthetic version of your original ETH (e.g., wETH), is created—or “minted”—in your wallet on the new chain. You now have a token that represents your locked ETH and is worth the exact same amount, which you can use freely within the new blockchain’s ecosystem. +3. **Burning to Return:** Now, let’s say you’re finished on the second blockchain and want your original ETH back. You initiate the return process by sending the wrapped token to the bridge contract on the destination chain. This contract then “burns” the token, which means it is permanently destroyed and removed from circulation. +4. **Unlocking the Original:** The burning of the wrapped token serves as a message back to the smart contract on the original chain. Once it receives this proof of burning, it automatically “unlocks” your original 1 ETH and returns it to your wallet. Adi refers to this as an “atomic action”—the burning on one side and the unlocking on the other are linked and must happen together. + +## Why Are Bridges a Common Target for Hacks? + +Despite their incredible utility, news headlines often feature stories of bridges being exploited for massive sums. Adi explains why these protocols are such tempting targets for hackers: + +* **High-Value Targets:** Bridges are like digital Fort Knoxes. They hold vast amounts of locked assets, making them a “honeypot” for malicious actors. A single successful exploit can yield a massive payday. +* **Infrastructural Complexity:** A crypto bridge isn’t a single piece of code; it’s a complex system of interacting smart contracts and sometimes off-chain components. The more complex a system is, the larger its “attack surface” becomes, meaning there are more potential vulnerabilities for hackers to find and exploit. +* **Trust Assumptions:** Not all bridges are created equal. Some are highly centralized, meaning users must trust a small group of operators or a single entity to manage the bridge honestly and securely. If that central entity is compromised, the entire bridge and its funds are at risk. On the other end of the spectrum are trustless and permissionless bridges, which rely on code and cryptography rather than human intermediaries. + +Adi emphasizes that the culture at StarkWare is focused on building StarkGate to be as trustless and permissionless as possible. “We want to put the trust in the smart contracts, in the code itself,” she says. By making the code open-source and reviewable, the power remains with the users, who always maintain control over their funds. + +## Navigating Crypto Crime with Jennie Levin + +The world of crypto is a place of incredible innovation and idealism, but like any financial frontier, it also attracts its share of bad actors. To navigate this landscape, the podcast brought in Jennie Levin, a true heavyweight in the legal and regulatory space. A former federal prosecutor who spent years putting criminals behind bars for fraud and money laundering, Jenny now helps Web3 teams stay on the right side of the law. She recently moved from her role as Chief Regulatory and Strategy Officer at Figment, a staking-as-a-service provider, to become the Chief Legal and Operating Officer at the Algorand Foundation. + +As a single mom who went through a remarkable journey involving surrogacy to have her two children, Jenny knows a thing or two about fighting for what matters. She brings that same tenacity and clarity to the complex world of crypto crime. + +## What Does a Classic Crypto Scandal Look Like? + +Jenny’s first point is a crucial one: “Crypto scandals are not just unique to crypto.” The types of fraud we see—like Ponzi schemes, market manipulation, or outright theft of funds—are the same schemes that have existed in traditional finance for centuries. The technology is new, but the underlying human greed and deception are not. A crypto fraud case often involves the same elements as a traditional one: misrepresentation, false promises of high returns, and the misappropriation of investor funds. + +The key difference, Nathan points out, is that the crypto space is less regulated, potentially giving bad actors more room to operate and victims less recourse. Jenny agrees but adds important nuance. + +## Regulation, Enforcement, and Recourse + +“When you have a public company… there are more hoops that you have to jump through, more regulatory hurdles,” Jenny explains. This constant oversight makes it much harder to hide a fraudulent scheme. In crypto, where many projects don’t have the same reporting requirements, a scam can sometimes go undetected for longer. + +However, she stresses that from a criminal enforcement perspective, the tools are the same. “If I’m at the US Attorney’s office and I wanna bring a case against somebody who’s committed a crypto fraud, I will use my money laundering, wire fraud, [and] mail fraud statutes, just like I would in any financial crime case.” Investigators use the same subpoena and search warrant powers, and victims have the same rights to restitution under the law. + +The regulatory landscape is maturing, with more checks and balances coming into place. While it’s not yet as defined as traditional finance, Jenny believes this evolution is a good thing for the industry’s long-term health. + +## A Balanced View: Don’t Let Fear Deter You + +So, how should a newcomer approach this space? Jenny advises against both blind trust and paralyzing fear. Her perspective is balanced and empowering: + +* **Crypto is the Future:** “Blockchain technology is the future, and so people should participate,” she states confidently. The technology offers a more secure and efficient way to transact. +* **Do Your Research:** The antidote to fear is knowledge. Before investing in or using a new protocol, take the time to understand it. Work with credible companies that have transparent processes and a history of prioritizing security. +* **Seek Guidance:** You don’t have to navigate this world alone. “Talk to your neighbor who’s involved in crypto. Call your lawyer and ask them some questions. Call your accountant,” she advises. Learn from people who are already in the space. +* **Fraud is Everywhere:** Finally, she offers a dose of reality. “There is fraud everywhere, and that is not, unfortunately, going to change. I don’t think that there’s more fraud in crypto than there is in other areas.” + +Jenny’s message is clear: participate, but do so with your eyes open. Education and due diligence are your best defenses. + +## Understanding the SEC’s Role with Katherine Kirkpatrick Bos + +If you’re building a project in the crypto space, there are three letters that can inspire both respect and anxiety: S-E-C. The U.S. Securities and Exchange Commission is a powerful regulator, and its actions have had a profound impact on the industry. To demystify this institution, the podcast turned to Katherine Kirkpatrick Bos, the General Counsel of StarkWare and a mother of two. Having helped shape the backbone of institutional crypto, Katherine has an expert understanding of how regulators think. + +### What Does the SEC Actually Do? + +“When people in crypto think of the SEC, they actually think of SEC enforcement,” Katherine notes. But that’s only one part of the picture. The SEC has multiple divisions that consult with market participants, help them interpret the law, and perform routine regulatory examinations. + +The division that makes headlines is the Division of Enforcement. Their job is to investigate potential violations of securities laws. If they find evidence of wrongdoing, they can bring an enforcement action, which might lead to litigation or a settlement. This is the part of the SEC that the crypto world has become most familiar with. + +### The Power of the Chair: Setting the Tone from the Top + +Gareth posed a timely question about the influence of the SEC’s leadership, particularly with the recent change in command. Katherine confirmed that the Chair has “a lot of influence” because, like any organization, the SEC’s direction is guided by its “tone from the top.” + +The previous administration under Chair Gary Gensler made crypto enforcement a major priority. This led to a period of intense scrutiny and what many in the industry called “regulation by enforcement.” One of the major criticisms of this approach was that the SEC dedicated a disproportionate amount of time and resources to crypto, which represents a small fraction of the overall financial markets. + +The crypto community is hopeful that the new Chair, Paul Atkins, will take a different approach. “We’re all hoping Chair Atkins appropriately sets a tone from the top that SEC enforcement should be focused not on registration issues, but on actual frauds and real wrongdoing in the securities markets,” Catherine says. A shift in priorities could mean a more collaborative and less adversarial relationship between the industry and its primary regulator in the United States. + +## The Real-World Utility of Stablecoins with Blue Macellari + +Our final guest, Blue Macellari, brings two decades of experience in traditional finance to her role as Head of Digital Assets at T. Rowe Price. As a mom of three, including 10-year-old twins and a 5-year-old “wildling,” she is no stranger to managing volatility. This makes her the perfect person to explain stablecoins—digital assets designed to eliminate volatility. + +## What is a Stablecoin? + +A friend of Nathan’s once seriously asked if a stablecoin was “something to do with horses.” Blue provides a much more accurate and simple definition: “You can take your one stablecoin and redeem it for $1. It makes it equivalent to a dollar on the internet.” In essence, it’s a crypto token whose value is pegged to a stable asset, most commonly the U.S. dollar. + +### How Do They Stay Stable? + +Blue explains that there are two main types of stablecoins, and the difference between them is crucial: + +1. **Reserve-Backed Stablecoins:** This is the most common and trusted model. “When you give them a dollar, the stablecoin issuer is holding onto that dollar,” Blue says. For every digital token in circulation, there is a corresponding dollar (or equivalent liquid asset like a U.S. Treasury bill) held in a verifiable reserve. This one-to-one backing ensures that users can always redeem their tokens for the real thing. +2. **Algorithmic Stablecoins:** Instead of relying on reserves, these stablecoins use a complex algorithm to manage their supply and maintain their peg to the dollar. Blue issues a word of caution here: “With an algorithmic stablecoin, it can, under certain circumstances, break from the one-to-one value. And what we’ve seen in crypto history is that when that happens, it can be a little bit ugly.” The collapse of algorithmic stablecoins in the past has wiped out billions of dollars in value, serving as a stark reminder of the risks involved. + +## Why Do We Need Stablecoins? + +Blue powerfully argues that the need for stablecoins is most acute in emerging markets. Drawing on her personal experience living in Brazil, she agrees with Tether’s Paolo Ardoino that these assets are a lifeline for millions. + +“It is really, really difficult not only to have a stable store of value in emerging markets, but also to do emerging markets cross-currency transactions,” she explains. If you want to trade the U.S. dollar for the British pound, the process is instant and cheap. But if you want to trade the Brazilian Real for the Colombian Peso, it’s a slow, multi-step process where fees are skimmed off at every stage. + +Stablecoins solve this by providing a universal, efficient, and stable medium of exchange. They facilitate trade, cross-border payments, and give people in countries with high inflation a way to protect their savings. + +To bring it home, Blue shared a personal story about trying to buy a wedding gift for friends in London while she was moving between Brazil and the U.S. Simple tasks like using PayPal or Zelle became a cross-border nightmare. “It took me two and a half days to try and attempt to get the money into John Lewis to buy the gift,” she recalls. “The bottom line was I could have sent stablecoin tokens from my wallet to their wallet, instantly, with almost no fees.” + +This is the power of stablecoins: they are the friction-free money of the internet, making global commerce and personal finance simpler and more accessible for everyone. + +## Conclusion: Clarity from the Experts + +This special Mother’s Day episode of the Clear Crypto Podcast delivered on its promise. By flipping the script and asking moms to be the explainers, we received four masterclasses in clarity, nuance, and real-world application. From Adi’s elegant breakdown of crypto bridges to Jenny’s balanced view on crime and regulation, Katherine’s expert dissection of the SEC, and Blue’s compelling case for stablecoins, the episode demonstrated that the people building and securing this industry are also raising the next generation. They are uniquely equipped to explain our complex world to the rest of us, and for their insights, we are all the wiser. + +--- +Sources: + - https://www.starknet.io/blog/starknet-grinta-the-architecture-of-a-more-decentralized-future/ +--- + +## Starknet Grinta: Advancing Decentralization & L2 Performance + +Home  /  Blog + +Sep 1, 2025 · 3 min read + +## Introduction + +The newly released version of Starknet – previously referred to by its numerical version name v0.14.0 and now known as ‘Grinta’ – marks a major milestone in Starknet’s decentralization journey by distributing the sequencer architecture. While Starknet previously operated with a single sequencer, it now has three independent sequencers running consensus and taking turns building blocks. + +This version of Starknet also includes some important user-facing features, including subsecond pre-confirmations, a mempool, a fee market, and a standardized integration to paymaster, all of which are discussed below. + +## Strides toward Decentralization + +The biggest change introduced by Starknet Grinta is a decentralized sequencing architecture consisting of three sequencers running consensus. Trust minimization is one Starknet’s core values and decentralized sequencing is essential to ensuring neutral transaction inclusion and ordering. Together with Staking v2, which was introduced in June 2025, this version of Starknet is a significant step toward putting the necessary technical infrastructure in place for the next phases of decentralization. + +During this version, the operation and control of the sequencers is still centralized under StarkWare; however, according to Starknet’s decentralization roadmap, block validation and production are distributed between several nodes operated by StarkWare, with fully decentralized sequencing and proving to come in the future. Decentralization is a core requirement for a public blockchain, and for Starknet this will mean that protocol security is managed through transparent, community-driven mechanisms. + +## Additional Features + +### Pre-Confirmations + +Starknet Grinta introduces incredibly fast, subsecond pre-confirmations, which means users receive the transaction status much earlier than block publication. In other words, pre-confirmation is a promise by the block proposer that a transaction is part of the proposal submitted to the consensus. The advantages of pre-confirmations for users are significantly reduced latency and the ability to act on transactions before L2 finality. + +### Mempool + +Mempools are also being introduced to Starknet with Grinta. Mempools store transactions waiting to be added to a block. They are continuously updated by adding, holding, deleting, and replacing transactions that are received. Starknet’s sequencers’ mempools are connected in a p2p network, so they are synced about transactions within a fraction of a second when there is no congestion. + +### Fee Market + +Another new feature focused on future-proofing Starknet is a fee market on l2\_gas. Prior to Grinta, the price of l2 gas was dependent on Ethereum’s gas price and, as a result, also affected by fluctuations on Ethereum. In addition, gas fees covered the “marginal” onchain cost of verification. However, due to significant technological improvements on Starknet, including advances in its proving stack and the introduction of blobs, onchain costs have become almost negligible. + +As Starknet moves toward decentralization, we are striving for a fee policy that incentivizes the participation of many sequencers. With this in mind, and together with feedback from the community, the minimum l2\_gas base price is set at 3 gFri. This base price ensures that fees cover the operational costs when gas prices on Ethereum are low, while improving the scale and costs when gas prices on Ethereum are high. + +### Standardized Paymaster + +Another new feature introduced by Grinta is a standardized paymaster interface. While Starknet had a paymaster in earlier versions, the interface was not standardized. The standardized interface brings compatibility across different dapps and crypto wallets, allowing devs to integrate with any paymaster without the need for custom logic which would vary on a per-vendor basis. + +## What’s Coming Next? + +The remainder of 2025 will see Starknet continue on its journey of becoming a better-performing and more decentralized network. On the decentralization track, decentralized validation is planned. This means that stakers will participate in the consensus and will vote on blocks. At least two-thirds of the stake will be required to sign off on blocks in order for them to be finalized. Only sequencers operated by StarkWare will propose blocks at that stage, with full decentralization set for a future version. + +As for performance, Starknet will move beyond 1000 TPS with the introduction of Cairo Native and will significantly reduce proving costs through improvements to S-two. Additional features, including faster L1 finality, better block times, and more are currently under discussion with the community. + +The name Grinta – meaning grit, resolve, or determination – captures our resolve to make Starknet the manifestation of the blockchain vision: a high-performance and widely-adopted economic hub that doesn’t compromise on security or decentralization. + +--- +Sources: + - https://www.starknet.io/blog/global-payments-settled-fast-on-starknet-powered-by-due/ +--- + +## Global Payments, Settled Fast on Starknet - Powered by Due + +Home  /  Blog + +Sep 4, 2025 · 2 min read + +## Introducing Due + +We’re thrilled to announce the launch of Due on Starknet! Due is a cost-effective global payments solution on top of interoperable blockchains and stablecoins, enabling anyone globally to send and receive funds and make payments as if they were local. + +Due can be seamlessly connected to your Braavos and Ready wallets on Starknet or to dapps via Due’s API for on- and off-ramps, cross-border payments, remittances, and more. It is available in over 80 countries and supports more than 30 fiat currencies, as well as USDC, EURC, and USDT stablecoins, with more in the pipeline. + +Due offers multi-currency virtual accounts for businesses and individuals in USD, GBP, EUR, MXN, and more to send and receive funds directly between local or foreign fiat currencies and stablecoins. It also provides access to multiple local payment rails, including ACH, SEPA, and Brazilian Pix, among others. + +As for security, Due is built with SOC 2-grade controls, provides real-time risk monitoring, and automated KYC/KYB, and is operated through licensed and regulated partners globally. + +This integration enables Starknet users globally to on- and off-ramp funds from USDC or USDT and send funds to bank accounts, mobile wallets, or directly to stablecoins. All Due transactions settle in under 24 hours, and, in the case of stablecoins, instantly, removing friction and unlocking new levels of financial inclusion. + +## What Sets Due Apart + +**Due offers incredibly low fees [1]:** + +* 0.2-0.5% on average vs the standard 4-6% for conversion rates. +* Wires that are 5-10 times cheaper than traditional wires. +* Free USDC transfers. +* USDC <> USDT 1:1 swaps with zero slippage. + +**In addition to being cheap, Due offers users virtual local accounts at no cost:** + +* Virtual accounts provide local payment details unique to each user’s account that can be used to receive payments locally. +* This allows individuals and businesses to receive payments without ever having to open a local bank account. + +**While Due users can easily connect their Starknet wallets, Due also allows users to open digital non-custodial crypto wallets with biometric key access.** + +* The wallets function like onchain accounts and instantly convert fiat payments to stablecoins that can then be held in the wallet. +* Users can manage multiple digital currencies no matter where they are. + +## Start Using Due Today + +* Sign up at app.due.network +* Create your Vault or connect an existing wallet to store your funds +* Verify your account +* Start moving your money! + +For more information, visit https://www.opendue.com/. + +This is not investment advice and this information is subject to change. Please do your own research and see terms and conditions here. + +--- + +[1] https://www.gsma.com/solutions-and-impact/connectivity-for-good/mobile-for-development/wp-content/uploads/2024/12/Cross-border-Mobile-Money-Remittance-Cost-Survey.pdf?utm\_source=chatgpt.com + +--- +Sources: + - https://www.starknet.io/blog/starknet-starter-pack/ +--- + +## Starknet Starter Pack: Your Guide to the ZK Rollup Ecosystem + +Home  /  Blog + +The Starknet ecosystem is evolving fast. With Starktember live and the BTCfi campaign launching soon, it's easy to feel overwhelmed by everything happening at once. + +Written by: Lyskey + +Sep 4, 2025 · 20 min read + +This starter pack is here to guide you: a complete overview of what you can do on Starknet today, and how to get started on mainnet right now. + +It covers everything you need, and even includes some alpha on how to make the most of Starknet. Whether you’re into **DeFi, gaming, content creation, or yield farming**, this guide is designed for you. + +## **Why Starknet?** + +What makes Starknet different from other Layer 2s? Before diving into this starter pack, let’s quickly cover **why Starknet exists**. I’ll keep it short, I’ve already written a full article on this topic if you want to go deeper. Most blockchains force you to choose: + +* Fast and cheap **or** decentralized and secure +* Easy to use **or** truly trustless + +Starknet exists to **end that trade-off**. Built from scratch with a new VM, a new proof system, and a new UX model, it delivers **all three pillars of the blockchain trilemma at once.** + +### **Scale without compromise** + +High throughput, low latency, and fees that decrease as usage grows; all while inheriting Ethereum-level security. + +Today, Starknet handles **1,000+ TPS**, with average confirmations in **~500 ms** and fees as **low as $0.002**. + +And this is only the beginning: capacity will scale beyond **10,000 TPS**, while latency keeps dropping over time. + +### **Decentralization & Security by Design** + +As a Layer 2 that settles on Ethereum, Starknet naturally inherits Ethereum’s decentralization and security. But unlike other L2s, Starknet achieves this **without compromise**: + +* It is the only ZK Rollup in production with zero trust assumptions, powered by STARK proofs, a quantum-resistant system with no trusted setup, and already battle-tested on billions of transactions. +* Recognized by L2Beat as a Stage 1 Rollup, Starknet is on track to reach Stage 2 and become fully trustless. +* Progressive decentralization is already underway through STRK staking, soon to be complemented by BTC staking, positioning Starknet as the most decentralized and secure L2 stack. So, beyond inheriting Ethereum’s security and delivering high performance, Starknet is also on the path to becoming fully decentralized. + +### **Web2-grade UX** + +From day one, Starknet was built with **native Account Abstraction (AA)** at its core. + +That means users on Starknet don’t face the usual crypto friction. Here’s how that translates in practice: + +* **1-click everything** → Bundling transactions (approvals + actions) into one click saves time and confusion. No more “approve → confirm → sign again.” +* **Gasless transactions** → Users don’t need to juggle ETH or STRK for gas. Fees can be abstracted away or sponsored by apps, removing one of the biggest onboarding barriers. +* **2FA / 3FA security** → Multilayer authentication is native on Braavos and Ready wallets. So even if one device or key is compromised, your funds stay protected. +* **Social logins** → Forget seed phrases. With account abstraction, you can spin up a wallet using your Google, Discord, or other familiar logins, making wallets as easy to create as any Web2 account. +* **Session keys** → Enable smoother gameplay and dapp interactions by letting apps temporarily sign transactions on your behalf. That means zero pop-ups while interacting onchain, perfect for gaming and social use cases. + +### **Long-term alignment** + +Backed by a team (StarkWare) with a multi-cycle track record of shipping industry-defining tech. As the saying goes: a picture is worth a thousand words, so here’s one: + +In short, Starknet delivers the performance developers need, the UX users expect, and the integrity blockchains promise, all at once. + +--- + +## **How to Get Started on Starknet** + +If you already have a Starknet-compatible wallet with funds on it, you can skip this part and jump to the next Section. For everyone else 👇 + +### **1. Starknet Wallets** + +The first step to join the Starknet ecosystem is to download a crypto wallet. You have several options here, but note that Starknet is not EVM-compatible, which means downloading a native Starknet wallet will unlock the full power of the network: 2FA/3FA security, gasless UX, Session Keys, and more. + +Currently, you have 3 native Starknet wallet options: + +* **Ready** **(formerly Argent)** → Session Keys, 2FA, gasless UX on browser, gasfree on mobile, plus a debit card for real-world payments +* **Braavos** → 2FA/3FA for enhanced security, gasfree UX on mobile, an integrated DeFi hub, Lightning Network integration for real-world payments, and more +* **Cartridge Controller** → a gaming-focused wallet that delivers a Web2-like UX when playing most games on Starknet (no gas fees, no popups, social logins via Discord/Gmail, invisible wallet) + +In addition to native wallets, you can also use some leading wallets from other ecosystems: + +* **Xverse** → the leading Bitcoin wallet, allowing you to manage Bitcoin, Starknet, and other Bitcoin L2s from a single UI. Note: Starknet integration on this wallet is still in its early stages and not yet fully connected to the ecosystem, but it’s coming! +* **Keplr** → the leading Cosmos wallet +* **MetaMask Snap****,** **Bitget Wallet****, and** **Ledger** + +Finally, the ecosystem is actively working to remove the EVM bottleneck by making all EVM wallets (MetaMask, Rabby, Phantom, etc.) compatible with Starknet. The solution is Rosetta, not yet production-ready but hopefully coming soon, which will enable a **native Starknet experience directly inside MetaMask and other wallets.** + +Pick one of these available wallets, and you’re already halfway through your Starknet journey. + +Once your wallet is ready, the next step is to fund it. There are two possible situations: either you have no funds onchain and need to deposit fresh capital, or you already hold funds on other chains and want to bridge them over. + +Let’s start with the first case: on-ramping. + +### **2. Buy Crypto on Starknet with Credit Card or Deposit from CEX** + +You’ve got two options 👇 + +#### **a. Buy with Credit Card** + +The easiest option is to purchase crypto directly inside your wallet using a credit or debit card. + +* On **Braavos**, you can use **Transak, Ramp Network, and Banxa**. +* On **Ready**, you can use **Banxa**. + +This method is fast and simple: all you need is a wallet and a card. Funds usually arrive within minutes. + +#### **b. Deposit from a Centralized Exchange (CEX)** + +If you already hold crypto on a CEX, you can transfer it to your Starknet wallet. Supported CEXs include **Binance, KuCoin, OKX, Bybit, Biget, HTX,** **Crypto.com****, Bithumb, Upbit, Gate, & MEXC.** + +This option is often cheaper than buying with a credit card, especially for larger amounts. + +### **3. Bridge Crypto to Starknet (Ethereum, Bitcoin, Solana & more)** + +If you’re already an onchain trencher, you can bridge your funds from all other ecosystems directly into Starknet using the following options: + +* **StarkGate** → the canonical Starknet bridge, supporting: Ethereum ↔ Starknet, Bitcoin ↔ Starknet (for Runes assets), Solana ↔ Starknet +* Bitcoin-focused bridges: **Garden** and **Atomiq Labs**, connecting Starknet and Bitcoin. +* For all chains: **RocketX Exchange** connects Starknet with 180+ chains, offering deep liquidity via CEX routing (great for large transfers). Other options: **LayerSwap**, **Orbiter Finance**, **Rango**, **RhinoFi**, **RetroBridge**, **Owlto**, **Minibridge**. + +Note that other bridges are coming: + +* **Hyperlane** is now integrated with Starknet; new bridges are under development using this technology. +* Two major interoperability protocols are expected to launch in **Q4 2025**. + +--- + +## **Starknet DeFi Ecosystem** + +Starknet has one of the most diverse and fast-growing DeFi ecosystems in crypto. Whether you’re here to trade, farm yield, or experiment with new primitives, you’ll find advanced tools already live on mainnet. + +Let’s break it down 👇 + +*Note: A few other options exist (mySwap, 10kSwap, Hashstack…), but I won’t cover them here since they are essentially inactive or abandoned. Instead, I’ll focus on the projects that are active and delivering real value on Starknet.* + +### **1. Spot trading** + +If you want to trade spot on Starknet, you have plenty of options. + +#### **AVNU (Aggregator)** + +In my opinion, the best option is **AVNU**, a DEX aggregator that pulls liquidity from all available sources on Starknet: AMMs, CLOB DEXs, and market makers. It’s also the most integrated trading hub in the ecosystem, powering much of Starknet’s trading UX. + +By trading on AVNU, you get access to all pairs on Starknet and the best available rates in one place. You can trade with a simple swap interface or use **DCA (Dollar-Cost Averaging)** to spread your orders across time. Limit orders are also in the works as far as I know. + +AVNU additionally provides chart views with up to one year of history. + +#### **Fibrous (Aggregator)** + +Another aggregator is Fibrous Finance, also live on Base and Scroll. Like AVNU, it aggregates all liquidity sources on Starknet for best execution. In addition to a classic swap, Fibrous offers a batch trading feature that lets you swap multiple tokens (more than two) at once, in a single transaction. + +If you prefer trading directly on DEXs rather than aggregators, Starknet offers three options. + +#### **Ekubo (AMM)** + +Ekubo is the most advanced and efficient AMM in crypto. It lets you trade using: + +* **Swaps** for simplicity +* **DCA** to spread your orders over time +* **Limit orders** for precise execution + +#### **Layer Akira (CLOB DEX)** + +Layer Akira is a spot CLOB DEX that allows traders to swap with access to price charts, order book history, and visibility into how much liquidity sits at each price level. Limit orders are coming soon, enabling traders to buy or sell assets at very precise prices. + +#### **Remus (CLOB DEX)** + +Remus DEX is another spot CLOB DEX, aiming to provide the full spectrum of features usually available on CEXs. Traders can view detailed charts for each pair, consult a transparent order book to see liquidity on both sides, and place either market or limit orders. As a reminder, limit orders allow you to buy or sell at exact target prices. + +This is basically all the relevant options you have for spot trading on Starknet. But what if you want leverage? Starknet now has two strong Perp DEXs live: one built natively on Starknet, and another operating as a Starknet appchain. + +### **2. Perp trading** + +When it comes to Perps, Starknet now has a truly **ultra-efficient Perp DEX** built directly on its chain (not as an appchain) by former Revolut executives: **Extended**. + +On Extended, you can trade with leverage across a wide range of markets: + +* Up to **50x** on ~50 crypto pairs +* Up to **100x** on traditional markets such as **EUR/USD, Gold, Oil and the S&P 500** + +But Extended isn’t only for traders. You can also become a liquidity provider by depositing into its vault, which currently yields over **25% APR in USDC**. Returns come from a mix of team-driven market making, trading fees, and liquidations. + +Note that Extended is running an **incentive campaign** where you can earn points by trading, providing liquidity, or referring new users. Just saying. + +Extended isn’t the only Perp DEX on the Starknet ecosystem. **Paradex**, built as a separate appchain closely connected to Starknet, offers similar features to Extended but without TradFi markets. + +Since this guide focuses on the **public Starknet chain only**, I won’t go into detail here. If you’d like to learn more, you can check out my full deep dive on Paradex + +Trading is great, but if yield farming is more your thing, Starknet also offers plenty of ways to put your assets to work. + +### **3. Yield farming** + +In addition to Extended’s vault, Starknet offers plenty of options for yield hunters. Whether you prefer lending, LPing, or liquid staking, there’s a growing ecosystem to put your assets to work. + +#### **Vesu (Lending & Borrowing)** + +Vesu is Starknet’s leading money market. Users can lend assets to earn yield or borrow against them. Lenders earn from two sources: + +1. Interest paid by borrowers +2. Incentives from the Starknet Foundation’s **DeFi Spring** program + +What makes Vesu attractive is its simplicity: + +* Earn passive yield by lending your assets +* Borrow additional assets to fuel your DeFi strategies + +A standout feature offered by Vesu is **Multiply**, which lets you create advanced looping strategies in a single click (though it also increases liquidation risk). + +**Example strategy I use:** + +* Lend ETH +* Borrow USDC at <2% +* Deploy USDC into Paradex’s vault (~25% yield) and Extended’s vault (~30% yield) + +Alpha: right now you’re essentially being paid to use your assets as collateral and borrow stablecoins. Just saying again 😉 + +#### **Nostra Finance (Lending, Borrowing & AMM Pools)** + +Another money market on Starknet is Nostra Finance. Like Vesu, it allows lending and borrowing, but currently Vesu offers better rates and more innovative features. Still, Nostra is worth watching for rate differences and opportunities. + +Beyond lending & borrowing, Nostra also offers **AMM pools**, where LPs can earn from both swap fees and DeFi Spring incentives. + +#### **FixedLend (Lending & Borrowing)** + +FixedLend is a smaller protocol, but with a powerful feature: an **Order Book of Yield.** + +* Lenders set both the **rate** and the **duration** of loans +* Borrowers choose whether to accept +* Once matched, loans are locked with a **fixed rate** and **defined maturity** + +This solves a key issue in classic money markets: variable rates that force constant monitoring. + +#### **Ekubo (AMM)** + +Beyond lending, Starknet has Ekubo, arguably the most efficient AMM in crypto. Thanks to ultra concentrated liquidity, gas-optimized execution, and its singleton design, every dollar of liquidity works harder: + +* Tighter spreads +* Lower slippage +* Higher fee capture + +For LPs, this means unmatched capital efficiency: earn more fees with less capital at risk. Proof? With only ~$20m TVL, Ekubo is already a top 2 DEX by volume on Ethereum. + +Ekubo also supports spot trading with swaps, DCA, and limit orders. + +If you want to dive deep into Ekubo, here is the most complete article to date about it + +#### **Troves (Automated Yield Optimizer)** + +Troves lets you deploy capital into advanced strategies with a single click. Examples include: + +* Lending on Vesu while auto-rebalancing to the best rates +* Weekly auto-claim and compounding of DeFi Spring rewards +* Looping strategies (lend → borrow → re-lend → repeat) +* Managing LP positions on Ekubo to maximize yield + +Troves handles it all automatically, meaning you can access these strategies and benefit from them passively with a single click. + +#### **Opus (Starknet Native Stablecoin)** + +Opus is the protocol behind Starknet’s only native stablecoin: **CASH**. You can mint CASH by depositing 7 types of collateral: ETH, STRK, wBTC, xSTRK, wstETH, Ekubo, and LORDS. + +CASH is particularly attractive because you can **stack three yield sources at once** with this stablecoin: + +1. Provide liquidity in the CASH/USDC pool on Ekubo +2. Stake the LP NFT on Opus to receive 75% of protocol revenue +3. Earn additional yield from U.S. Treasury exposure (T-bills) + +As of August 2025, the APY is ~**18%**. + +#### **Endur (Liquid STRK & BTC staking)** + +Endur currently offers **liquid STRK staking.** You stake STRK to secure the Starknet’s network, earn rewards (~6.5% APR), and receive a liquid token (xSTRK) you can use across DeFi. Example strategy: + +* Stake STRK on Endur (~6.5% APR) +* Lend xSTRK on Vesu (~3% APR) +* Borrow USDC against it +* Deploy USDC into Extended or Paradex vaults for high yield (~25%) + +This dual benefit makes Endur a cornerstone of Starknet’s DeFi stack. + +Soon, Endur will also support liquid BTC staking once Bitcoin staking goes live on Starknet (expected in the coming weeks). + +### **4. Other DeFi Primitives on Starknet** + +Starknet’s DeFi stack doesn’t stop at lending, DEXs, and staking. A growing set of other DeFi primitives are live, covering savings, payments, prediction markets, options, and token launches. + +#### **Bountive (No-Loss Prize Savings)** + +Bountive introduces a **no-loss savings mechanism** that turns yield farming into a lottery-style game. + +How it works: + +* Users deposit assets into a pool +* Funds are deployed into DeFi strategies by Bountive +* Yield is used to fund **lottery prizes**, distributed among winners +* Deposits remain withdrawable at any time + +This model blends **savings + gamification**, replacing fixed APR with the chance to win **much bigger rewards**. + +#### **Raize Club (Prediction Markets)** + +Prediction markets have historically been one of the few DeFi primitives with real traction, and Starknet has its own: **Raize Club**. + +* Bet on outcomes ranging from crypto prices to real-world events +* Place a bet in one click +* Choose from **four different tokens to place your bets** (not just USDC, unlike most prediction markets) + +The mix of simplicity and flexibility makes Raize Club stand out. + +### **Payments on Starknet** + +When it comes to payments, three main products are currently live on Starknet. + +The first is **Pulsar Money**, which makes crypto payments as simple as sending a tweet. + +Integrated directly with **X (Twitter)**, Pulsar enables frictionless transfers between users. It’s perfect for tipping your favorite creators or boosting the reach of your posts by attaching a prize pool for those who engage. + +The second is the **Ready Card**, a crypto debit card by Ready, Starknet’s native wallet. You can pay anywhere Mastercard is accepted using your onchain USDC, with no FX fees, and even earn up to **10% cashback** on daily spending. It’s the perfect bridge between your onchain assets and real life. + +Finally, there’s **Braavos**, the second Starknet’s native wallet, which integrates the **Bitcoin Lightning Network**. + +This lets you use Lightning payment terminals directly from Starknet. In practice, you just open your Braavos mobile wallet and scan a QR code to pay instantly anywhere Lightning is accepted. + +#### **Carmine Options (European-style options)** + +**Carmine Options** is the first options protocol live on Starknet, bringing **European-style options** fully onchain. + +For context: **European options** are financial contracts that give you the right, but not the obligation, to buy (call) or sell (put) an asset at a set price, but only on the option’s expiry date. + +Carmine makes this powerful primitive accessible on Starknet, enabling users to: + +* Speculate on price moves with limited downside risk +* Protect against sharp drops in asset prices +* Hedge impermanent loss for LP positions +* Provide liquidity to earn fees on options markets + +Currently, Carmine supports calls and puts on **ETH, STRK, wBTC, and Ekubo.** + +#### **Unruggable (Token Launchpad)** + +**Unruggable is Starknet’s native token launchpad, built to make memecoin launches safer and fairer.** + +For **creators**, it offers a **no-code interface**, so anyone can launch a memecoin in just a few seconds, with no technical skills required. + +For **traders**, every launch comes with built-in protections: + +* Liquidity locked for at least **6 months** (or forever if none is added) +* Team allocation capped at **10%** (max 5% per member) +* **Anti-whale rules** in the first 24 hours to ensure fairer distribution + +Tokens certified as **“Unruggable”** can be verified directly on the official site or through platforms like AVNU, where a badge confirms the certification. + +--- + +## **Onchain Gaming on Starknet** + +Starknet hosts the most advanced **fully onchain gaming ecosystem** in crypto. Unlike the “Web2.5” experiences other chains brand as onchain gaming, most Starknet titles run entirely onchain: every mechanic, every asset, every interaction. + +Why does this matter? Because being fully onchain means true **ownership** of everything you create or earn, and games that cannot simply vanish. We’ve already seen the opposite with *Pirate Nation* on Arbitrum, which shut down its instances; something impossible when a game is entirely onchain. + +#### **Realms (Age of Empires Onchain)** + +The flagship game on Starknet is **Realms** (formerly Eternum). It captures the spirit of Age of Empires, Civilization, and Travian, but fully onchain. + +Realms is a grand strategy game where you expand your realm, manage resources, trade, form alliances, betray, and wage wars for dominance. + +In recent months, Realms has rolled out major improvements, not only in design and gameplay, but also in accessibility: players can now log in via the **Cartridge Controller** using Discord or Gmail accounts, and even connect with EVM wallets. + +The team has also introduced two distinct modes: + +* **Eternum** → the full, long-form version, where matches last several weeks. +* **Blitz** → a fast-paced mode designed for quick 2-hour sessions. + +The first Eternum seasons launched in the past months, and new seasons are coming soon, this time featuring the brand-new Blitz mode. + +#### **BlobArena (Pokémon-Inspired Battles)** + +**BlobArena** is a playful, onchain reinterpretation of Pokémon, focused entirely on **fighting**. Players control Blobs in fast-paced duels, with every move executed onchain. + +A recent partnership with **AMMA (Armored Mixed Martial Arts)** brought BlobArena into the real world, distributed and showcased at AMMA’s live events. This makes it the first fully onchain game with real-world competitive integration. Powered by Starknet. + +#### **Art Peace (r/Place Onchain)** + +One of the most creative experiments on Starknet is **Art Peace**, a **shared onchain canvas** built by StarkWare and inspired by Reddit’s iconic *r/Place*. Just like on Reddit, anyone can place pixels on the canvas, but here, every action is recorded fully onchain. + +The concept transforms creativity into gameplay: users collaborate (or compete) to design mosaics, leave messages, or build collective masterpieces. Beyond being a playground for creativity, **Art Peace has become a tool for community engagement**. Projects and DAOs regularly use the canvas to launch mini-competitions with prize pools lasting several days. + +Follow the project closely, you might win something, and you’ll definitely have fun. + +#### **PonziLand (token-agnostic DeFi metagame)** + +The concept behind PonziLand is simple, and very degen: you **buy land** on the PonziLand grid, set a resale price in any token (STRK, PAPER, LORDS…), and the game begins. + +Each day, you pay a **small tax** (based on your land’s price) to your **neighbors**. You pay in your token but receive taxes in theirs. If their tokens pump harder, you profit; if not, you get rugged. It’s a constant battle of **strategy, speculation, and neighbor wars**. Conquer plots, optimize your exposure, and climb the map to become a true **PonziLord**. + +The game runs in **seasons**, so you’ll need to wait for the next one to begin (coming soon 👀). + +#### **Jokers of Neon (Poker strategy)** + +Jokers of Neon is THE game for poker lovers. + +In this game, you start with a deck of cards, and each round you have a limited number of plays to score as many points as possible. Points come from forming classic poker hands (pairs, straights, flushes, full houses…), and stacking them with in-game combos and bonus multipliers. + +The strategy lies in choosing whether to play the cards in your hand or discard them to draw new ones, chasing that perfect combination before you run out of moves. + +And of course, every single move happens fully onchain. + +#### **Force Prime Heroes (Heroes of Might and Magic Onchain)** + +Force Prime Heroes is a strategy game where you explore the map with your hero, gather resources, recruit units, and grow your army to ultimately defeat the **Bone Dragon** or other bosses. Each move consumes movement points (structured in days and weeks), income flows from captured buildings, and your final score depends on both **efficiency and speed**. + +Victory requires balancing hero progression, smart recruiting, and efficient map control. + +Oh, and you can even **design your own maps** here: Force Prime Editor + +#### **Pistols at Dawn (Cowboy Duels Onchain)** + +Pistols at Dawn is a 1v1 showdown where you face another Lord in a classic Western-style pistol duel to defend your honor. The rules are simple: challenge a friend or any opponent, and step into a high-stakes standoff. + +Every shot, every victory, every defeat is recorded fully **onchain.** + +#### **Dark Shuffle (Roguelike Deck-Builder)** + +Dark Shuffle is a fully onchain card-based strategy game. + +At the start of each run, you draft 20 cards to define your initial strategy. From there, you dive into **randomly generated maps** filled with branching paths. Every choice, which path to take, which card to play, or which battle to risk, shapes your journey and determines how far you can go. + +#### **Dope Wars (Hustle & Empire Building)** + +Dope Wars is a fully onchain strategy and role-playing game. + +Players start as hustlers in a gritty world, with one simple goal: **buy low, sell high, build your empire, and outsmart your rivals.** + +#### **zKube (Onchain Puzzle Challenge)** + +zKube is a fully onchain **puzzle game**, blending **Tetris** with sliding-block mechanics. You manipulate patterned blocks on a grid to solve challenges step by step, blockchain logic makes every move verifiable. + +#### **ByteBeasts (Tamagotchi)** + +ByteBeasts is **Tamagotchi reborn**, fully onchain on Starknet. Mint your digital pet, feed it, nurture it, bond and play with it. + +#### **Evolute (Carcassonne Meets Mage Duels)** + +Two sorcerers face off on an 8×8 grid, shaping Cities, Roads, and Fields with each tile they place. Tiles must connect logically, and control is gained by completing constructions, but territory can always be contested. Points from Cities and Roads decide which mage emerges victorious. + +Evolute is onchain, but settling on Celestia. + +--- + +## **Best tools on Starknet** + +DeFi and gaming are cool, but you need solid tooling to really get the most out of Starknet. Here’s the list of the most important ones. + +#### **Ready Portfolio (Portfolio tracker)** + +Beyond its role as one of Starknet’s native wallets, Ready also offers a **portfolio dashboard**. It allows you to track your (or someone else 👀) assets, positions, and DeFi allocations across the network in a simple and intuitive interface. + +#### **AVNU Market** + +AVNU launched a **DEXscreener-like platform**: AVNU Market. It lists all available markets on Starknet and offers a wide range of analytics for each asset, price charts, liquidity depth, trading volumes, and more. + +A must-have for traders tracking tokens in real time on Starknet, and a great complement to Dexscreener and GeckoTerminal. + +#### **StarkPulse** + +StarkPulse is a **Telegram bot** designed to monitor Starknet’s onchain activity. It lets you: + +* Track specific wallets and receive instant alerts when they buy or sell assets. +* Get notified when a new token is created on Starknet. + +In practice, StarkPulse puts the onchain trenches directly in your Telegram feed. It’s still relatively unknown on Starknet, so here’s the alpha. + +#### **Cartridge Arcade** + +Imagine having one single interface that brings together most of the games on Starknet, with a point system and a leaderboard to compete against all other Starknet gamers. + +That’s exactly what Cartridge Arcade offers. It showcases all the games built on the Cartridge/Dojo ecosystem (which powers most of Starknet’s gaming scene), lets you jump in, play easily, and track your progress compared to other players. + +Think of it as Steam for Starknet gaming. + +#### **Voyager** + +Voyager is one of the first and most widely used **block explorers** on Starknet. Similar to Etherscan on Ethereum, it provides transparency into every transaction, contract, and wallet on the network. It also offers high-level insights into Starknet’s activity in real time. + +#### **Starkscan** + +Starkscan is another major block explorer on Starknet, providing a different UI/UX. + +#### **Focus Tree** + +Focus Tree is a productivity app designed to help you win back your attention. It lets you: + +* Set focus timers + +* Block distractions on your phone + +* Earn items by completing sessions + +* Build your digital garden + +In practice, Focus Tree turns deep work into a game, making discipline visible, distractions costly, and progress rewarding. + +--- + +## **Bonus: How to Contribute to Starknet with the Wolf Pack League** + +The **Wolf Pack League (WPL)** is StarkWare’s flagship community program, created to accelerate Starknet’s growth. The vision is simple: just like wolves are stronger together when they hunt in packs, Starknet thrives when its community of builders, creators, and contributors moves forward as one. **To turn this vision into reality, the WPL connects projects and contributors through two complementary programs:** the WPL Platform and WPL Attested Creators. + +#### **a. WPL Platform** + +The WPL Platform is **open to everyone**. It acts as a **marketplace of collaboration** where projects and community members meet: + +* **Projects** can create missions (specific bounties/tasks) and open them to the whole Starknet community. +* **Contributors** can browse these missions, pick the ones that fit their skills (content, design, development, research, etc.), and submit their proposals. +* **Rewards** are then distributed by the projects to the winning submissions, ensuring fair recognition and value exchange. + +This system gives projects a way to boost their visibility and growth while empowering contributors with opportunities to showcase their talent, earn rewards, and become more deeply involved in Starknet. + +#### **b. WPL Attested Creators** + +The second pillar of the WPL highlights long-term contributors: the **Attested Creators**. These are individuals who have been consistently pushing Starknet forward with **high-quality content and meaningful contributions**. + +* The more they contribute, the more they **grow in reputation** within the program. +* In addition to the rewards available on the open WPL platform, attested creators receive **extra recognition and benefits** for their sustained impact. + +In other words, **Attested Creators are the pack leaders,** trusted voices who inspire others while being rewarded for their consistency and dedication. And if you keep contributing, you might soon join them. + +Starknet is the best place to start contributing and gain recognition for it. And the right time to start is now. + +--- + +## **Conclusion** + +The foundations of Starknet are stronger than ever, with all the core primitives now in place to build increasingly advanced use cases on top. Yet it’s still **day one** for the ecosystem: there’s plenty of room for anyone to make their mark, and programs like the **Wolf Pack League** make it easier than ever to get involved. + +But don’t wait too long: momentum is accelerating, with **Starktember now live and BTCfi only a few weeks away. The best time to join is NOW.** + +In the meantime, make sure to follow the full Starknet crew to stay up to date with everything happening across the ecosystem. **See you on the other side.** + +This article was also publishes on Lyskey’s blog. + +--- +Sources: + - https://www.starknet.io/blog/defi-perpetuals-on-starknet-and-the-future-of-onchain-trading/ +--- + +## DeFi Perpetuals on Starknet and the Future of Onchain Trading + +Home  /  Blog + +Share this post: + +Aug 9, 2025 + +Ruslan joins the stage to discuss his journey from leading crypto operations at Revolut to founding Extended, a next-generation DeFi perpetual exchange. He shares his background in scaling Revolut’s crypto division to millions of users, the lessons learned from the FTX collapse, and the vision behind Extended: a decentralized perpetual exchange with cross-asset collateral, integrated spot, and lending markets- all built on Starknet. + +We dive into: + +– Ruslan’s crypto story and time at Revolut + +– Why Extended chose Starknet for settlement and scalability + +– How cross-asset collateral and unified margin change the game + +– Lessons from FTX and the importance of onchain settlement + +– Extended’s path to $1B+ daily trading volume + +– The competitive landscape of perpetual exchanges + +--- +Sources: + - https://www.starknet.io/blog/the-zk-proving-race-starkwares-vision-for-the-future-of-zero-knowledge-proofs/ +--- + +## Stwo, Cairo, and the Future of Zero-Knowledge Proofs + +Home  /  Blog + +Share this post: + +Aug 20, 2025 + +In this conversation, Maya from StarkWare dives deep into the ZK proving race- the push to make proving faster, cheaper, and more scalable. We explore what the proving race means for StarkWare, how new provers like Stwo are reshaping efficiency, and why client-side proving on laptops and mobile devices could unlock massive new use cases for blockchain and beyond. + +Key topics covered: + +– The ZK proving race and its impact on Ethereum and StarkWare + +– The role of new provers (Stwo, Cairo) + +– How local proving on consumer devices opens up new possibilities + +– Applications in DeFi, KYC, privacy, and beyond + +– Why adoption, not technology, is the real barrier + +– The future of ZK rollups and general-purpose proving + +--- +Sources: + - https://www.starknet.io/blog/starknet-incident-report-september-2-2025/ +--- + +## Starknet Incident Report — September 2, 2025 | Starknet + +Home  /  Blog + +Sep 11, 2025 · 4 min read + +On September 2, 2025, shortly after upgrading to version 0.14.0 (Grinta), Starknet experienced an outage during which block production was halted and two chain reorganizations (reorgs) were required to restore normal operation. + +We recognize the impact this had on our users and partners, and we are committed to providing full transparency into what happened, how it was resolved, and what steps we are taking to prevent recurrence. + +This incident occurred in the immediate aftermath of a historic milestone: **Starknet became the first Validity (ZK) rollup to decentralize its sequencer architecture, moving from one to three sequencers operating the network.** That shift was the core change that exposed this new challenge – one that is inherent in pioneering the path toward decentralization, a path that only Starknet has taken so far. + +Since the incident ended on September 2 at 13:41 UTC, Starknet has been fully operational. We are continuing to push the boundaries of proving and advancing toward becoming the first decentralized Validity (ZK) Rollup, while also applying the key insights from this incident to further strengthen Starknet’s resilience going forward. + +## **Summary** + +Between **02:20 and 13:40 UTC**, Starknet was intermittently unavailable. During that time, two reorgs were required: + +* The first reverted roughly **one hour of transactions**. +* The second reverted roughly **20 minutes of transactions**. + +The downtime was caused by a sequence of three interconnected incidents, beginning with a failure in Ethereum RPC providers at the node logic level. + +A deeper investigation identified the following contributing factors: + +**1. Ethereum node failures** – The three Starknet sequencers, which operate as part of its decentralized architecture, observed different states of Ethereum. This divergence disrupted the block-proposing process: one sequencer proposed transactions triggered by Ethereum messages that the others could not validate. As a result, network progression slowed significantly. + +**2. Manual intervention gap** – To address the sequencer failures discussed above, a manual intervention was required. In this manual process, certain validations that are performed automatically were skipped, which resulted in the creation of two conflicting blocks in the L2 layer by the different Starknet sequencers. To restore correctness, a reorg was performed. + +**3. Blockifier bug in v0.14.0 –** After the first reorg, transactions were discarded but L1→L2 messages were reprocessed. Some of these messages assumed that earlier Starknet transactions had already been executed, and when that assumption failed, they reverted. This triggered a bug in the blockifier – the component responsible for updating Starknet’s state based on transaction execution. The bug affected how reverted transactions initiated by L1→L2 messages were handled. This compounded the earlier disruptions and required both a hotfix and a second reorg to fully resolve. + +When analyzing the failures, we identified issues in the **consensus mechanism** and **blockifier logic**, which will be detailed further below. + +It is important to note that throughout the incident, **Starknet’s proving layer acted as the safeguard** that prevented these inconsistencies from compromising the integrity of the blockchain. This design reflects a core principle of Starknet: to preserve correctness and security regardless of any undesired sequencer behavior-whether caused by software bugs or by malicious activity. + +## **Impact** + +* **Downtime**: Approximately 9 hours of degraded or halted service. +* **Reorgs**: All transactions in the affected blocks reflecting ~1.5 hours of activity were not processed and needed to be resubmitted. + +## **Timeline** + +At **02:20 UTC**, initial issues were detected when sequencers failed to sync L1 events, preventing new blocks from being approved. An investigation was initiated immediately. By **03:57**, after several manual attempts to reset individual sequencers, L1 synchronization succeeded and Starknet resumed. + +At **04:10 UTC**, an alert indicated that the proving layer had detected an inconsistency, marking the beginning of the second incident. Apparently, different sequencers were building blocks on top of different versions of a certain block, and this was a result of our previous manual intervention. Starknet, as a validity rollup, first sequences blocks, and later proves them. When the proving layer detects an inconsistency (or any other invalid logic), it cannot generate a valid proof. By **04:37 UTC**, Starknet was manually halted, since it became clear that a reorg might be required in order to fix this issue. This approach is based on the principle that when a reorg is anticipated, halting the system helps to minimize potential transaction loss. + +At **06:05**, we identified the block where the inconsistency occurred, and thus decided to re-org back to the block before (1,960,612), , reverting approximately one hour of activity. Block production resumed at **07:42** and by **09:08** all full node clients were synced and Starknet operations were fully restored. + +The third incident began at **10:28**, when the proving layer identified another inconsistent batch. At **10:43**, Starknet was halted again as the probability for a second reorg became high. By **12:05**, the root cause was identified, and at **12:37** a bug fix was implemented, tested and deployed. At **13:29**, a second reorg was executed from block **1,962,681**, reverting roughly 20 minutes of activity. Finally, at **13:41**, block production and full network activity were restored. + +## **Key learnings and Prevention Measures** + +In addition to detecting, analyzing, and rapidly fixing the bugs that caused this failure, and adding safeguards that will automatically prevent such failures from recurring, we are also implementing a set of measures designed to further reduce the likelihood of similar issues in the future: + +* **Increase the number of nodes** participating in the internal consensus protocol to improve fault tolerance and resilience. +* **Introduce additional safety mechanisms** to protect against disruptions when external dependencies, such as Ethereum nodes, experience issues. +* **Minimize the need for manual interventions** and ensure that in the rare cases they are required, the process is reliable, well-documented, and resistant to human error. + +## **Closing** + +Starknet is back online and fully operational. While the incident was serious, the fixes applied have already increased network resilience, and additional long-term improvements and safeguards are being implemented. + +By identifying and addressing these bugs immediately upon detection, and with the proving layer serving as a backstop, Starknet emerges more robust. The fixes applied in response, together with additional safety precautions now being implemented, directly strengthen its reliability going forward. It is also worth noting that the Starknet dapp teams were well-prepared to handle reorgs, which ensured users were minimally affected at the application level throughout the incident. + +We are committed to full transparency with our users and partners, and will continue to share follow-up updates as improvements are rolled out. + +**Thank you, Starknet community, for your understanding and support as we worked through this issue.** + +--- +Sources: + - https://www.starknet.io/blog/defis-practical-era-itamar-on-stablecoins-neobanks-the-future-of-ready/ +--- + +## DeFi 3.0 | Stablecoins, Institutional Adopztion & Ready’s Vision + +Home  /  Blog + +Share this post: + +Sep 9, 2025 + +Itamar joins Andy and Robbie from The Rollup for a deep dive into the next phase of DeFi—what he calls the practical era. From Argentina’s booming crypto culture to the evolution of wallets into full-scale financial applications, Itamar explains how DeFi is moving beyond experimentation into real-world adoption. + +We cover: + +* Why Argentina is a unique testbed for stablecoins and crypto neobanks +* The Ready card and neobank product bridging crypto and traditional finance +* Institutional adoption and DeFi’s shift toward liquidity protocols +* Stablecoins as the Trojan horse for mass adoption +* The future of wallets, Starknet, and crypto-powered banking +* Lessons from building through multiple market cycles + +Whether you are a DeFi veteran or just exploring how crypto integrates into everyday life, this conversation highlights where the industry is headed. + +--- +Sources: + - https://www.starknet.io/blog/builders-defi-gaming-btcfi-on-starknet/ +--- + +## Builders, DeFi, Gaming & BTCFi on Starknet | Ecosystem Growth + +Home  /  Blog + +Share this post: + +Sep 28, 2025 + +Join Victor and Shadowfax from StarkWare’s ecosystem team to unpack Starktember—a month-long push to supercharge builders, users, and creators across Starknet. We cover what’s live now, what’s coming next, and how ~1,000,000 STRK in rewards are being allocated across hackathons, app competitions, and community bounties. We also look at the surge from Extended (on-chain perps), the latest UX upgrades (pre-confirmations, native AA, paymasters), and a peek at the post-Starktember roadmap: BTCFi and BTC staking on Starknet. + +--- +Sources: + - https://www.starknet.io/blog/eli-ben-sasson-on-bitcoin-starknet-and-the-future-of-decentralization/ +--- + +## Eli Ben-Sasson on Bitcoin, Starknet & the Future of Decentralization + +Home  /  Blog + +Share this post: + +Sep 28, 2025 + +In this episode, Andy sits down with Eli Ben-Sasson, co-founder and CEO of StarkWare, to discuss the evolving landscape of crypto and blockchain. + +Eli shares his 12+ years of perspective in the industry—from launching Zcash in 2014 to building StarkWare and Starknet today—and explains why the future of crypto lies in a *return to fundamentals*. + +We discuss: + +* Why crypto still lacks global product-market fit +* The cycles of hype vs. long-term fundamentals (payments, stablecoins, credentials) +* Why fully decentralized systems (Bitcoin, Starknet) are the true end state +* Institutional adoption, stablecoins, and the role of corporate chains +* The coming wave of Bitcoin staking on Starknet +* Decentralizing the sequencer and scaling Ethereum with ZK-STARKs +* The importance of privacy, UX, and self-custody for mainstream adoption + +Eli also explains why he believes Starknet is best positioned to become the Bitcoin settlement layer, shares updates on Starknet’s decentralization milestones. + +--- +Sources: + - https://www.starknet.io/blog/why-bitcoin-staking-is-a-big-deal/ +--- + +## Starknet Launches Bitcoin Staking + +Home  /  Blog + +Starknet now supports Bitcoin staking. It's a simple headline, but it has profound implications. + +Sep 30, 2025 · 4 min read + +Some 98.5% of Bitcoin sits idle on the Bitcoin network. This represents USD$ 2 trillion worth of value that is unutilized and locked away. It is no surprise then that an increasing number of projects are trying to unlock this value. In the world of DeFi, for example, Bitcoin value could drive deeper liquidity, more efficient markets and serve to unlock entire ecosystems and use cases. + +Value is equally important in the world of decentralization and distributed consensus. For Proof-of-Stake networks, like Ethereum and Starknet, the security of the network is directly correlated to the value staked. Enabling Bitcoin to stake and secure Starknet is a major milestone for both Starknet and Bitcoin. + +## How Starknet Immediately Benefits + +Starknet’s Bitcoin staking will immediately increase the value of the assets that are staked to secure Starknet. Today, there are 65,000+ delegators and 550 million+ STRK staked. The launch of Bitcoin staking will increase this number and thereby enhance the security characteristics of Starknet. Simply on those merits, Bitcoin staking is a significant development. + +Remember, Bitcoin is generally regarded as lower risk and a very attractive relative to other cryptocurrencies. As a result, Bitcoin holders require lower rewards than other cryptocurrencies to participate in similar programs. This means that in the long-term, Bitcoin staking is cheaper than STRK staking for an equivalent level of cryptoeconomic security. + +Starknet is uniquely positioned to rollout a successful Bitcoin staking protocol. Most networks, especially L2s, do not have a sufficiently adopted and decentralized staking program for their native token. If a network ends up with only Bitcoin stakers, it dilutes the role of its native token and its governance processes. The large adoption of STRK staking on Starknet enables the rollout of a successful Bitcoin staking program. The governance proposal that was approved is very detailed on how STRK and Bitcoin support each other. The consensus power of staked Bitcoin is limited to 25% of the network. STRK will hold the remaining consensus power, ensuring STRK staking maintains its centrality in securing starknet. + +## The Bitcoin Flywheel + +**But it gets better**: Bitcoin staking on Starknet kicks off a significant flywheel for the entire Starknet ecosystem. Here’s how: + +Bitcoin staking on Starknet will bring significant amounts of Bitcoin to the Starknet ecosystem, sustainably and perpetually. This will enhance the security characteristics of the network and the liquid TVL on Starknet. Enhanced security and increased liquidity in turn will attract more builders and assets to the entire Starknet ecosystem, further increasing the amount of STRK staked. By the mechanism designed and approved for Bitcoin staking, this increase in STRK staking will result in an increase in the rewards distributed to Bitcoin stakers, further incentivizing Bitcoiners to stake their Bitcoin, starting what is a powerful, reinforcing flywheel on Starknet. + +Let’s break down these components into more detail: + +Starknet’s Proof-of-Stake, like all PoS systems, rewards participants for securing the network by giving them newly created tokens, in this case STRK. These emissions are a naturally occurring part of PoS networks (and PoW networks too). They do not require special incentives. They are not one time programs. They do not depend on activity farming or other short-term behaviours. These rewards are part of a long-term, sustainable program. + +As already discussed, the more assets that are staked on a network, the more secure the network is. Enhanced security drives adoption. More Bitcoin staked also drives adoption in another meaningful way: liquid-staked tokens. Bitcoin stakers have the possibility to participate in liquid-staking programs, where they receive a derivative token representing their staked positions. Just like on other PoS networks, these liquid stake tokens themselves can be used to drive usage in DeFi. + +This in turn boosts STRK’s utility, as it is Starknet’s core asset: + +* Default token for gas and staking +* Governance token +* Main DeFi collateral +* Next up: a fee-burn (ETA TBD) aimed at reducing supply as usage scales. + +The amount of STRK staked is what determines emissions for both STRK staking and Bitcoin staking. This was implemented to make sure that STRK maintains its dominant position in securing Starknet. The mechanism for determining emissions increases emissions for both STRK and Bitcoin when more STRK is staked. This positive relationship is critical for securing Starknet with both BTC and STRK. + +## Why Should Bitcoiners Care? + +Bitcoin Staking (and the broader BTCFi rollout) is another step on Starknet’s journey of decentralization, innovation and security. + +Earlier this year, Starknet announced it became a Bitcoin and Ethereum L2. Starknet wants to leverage the security of both layers, and use its STARK-based zk-L2 to provide scale, security and low-cost transactions to both Ethereum and Bitcoin, without sacrificing decentralization. Last month, Starknet’s Grinta upgrade was yet another big step. Starkware has also released significant research and software on Bitcoin and zero-knowledge cryptography, including research on ColiderVM, providing a toy implementation of ColiderVM, setting up a $1m research fund on OP\_CAT and setting a world record for proving Bitcoin mainnet with ZK proofs. And the roadmap is accelerating. + +Bitcoin staking presents an opportunity for Bitcoin holders to support a leading project promoting decentralization, cryptography, privacy and security, while also earning sustainable rewards. + +For the first time, Bitcoin holders can stake their Bitcoin to secure a Layer 2 and earn sustainable rewards. + +To learn how to stake your tokens, see the Bitcoin User Guide here. + +--- +Sources: + - https://www.starknet.io/blog/introducing-the-re7-yield-aggregator-on-starknet/ +--- + +## Re7 Labs Yield Aggregator Live on Starknet + +Home  /  Blog + +Sep 25, 2025 · 2 min read + +We are excited to share that the ****Re7 ALMM by Re7 Labs is now available** on Starknet**. This new product is designed to make yield generation simple, sustainable, and accessible to anyone interested in DeFi. + +## **What Is the Re7 **ALMM**?** + +The Re7 ALMM is the Automated Liquidity Market Maker, built specifically for **Ekubo liquidity pools on Starknet**. It continuously monitors APRs and market activity and automatically rebalances LP positions. The result: your assets are always working. + +Instead of having to check and rebalance constantly, you simply deposit your assets once. From there, the ALMM does the work in the background, keeping your capital efficient. + +## **Turning DeFi Challenges into Opportunities** + +Starknet is rapidly becoming a leading destination for scalable DeFi. With this growth comes new opportunities, but also new challenges for users. One of the biggest pain points is managing liquidity positions effectively. + +Traditionally, this requires building complex strategies, keeping up with APR changes, and constantly adjusting positions. For many, that barrier is too high. Re7 set out to solve this problem: to give users the benefits of advanced yield strategies, without the complexity that usually comes with them. + +## **The How** + +Managing liquidity is often time-consuming, and even experienced users can struggle to capture optimal yield consistently. Re7 makes the process more straightforward: + +* + No strategy building required. + +* + No ongoing monitoring needed. + +* + Just deposit and earn. + +Vaults are built on top of Trove’s audited and tested on-chain infrastructure, combined with Re7 Labs’ proprietary rebalancing strategy. + +## **Re7 in Action: Features That Matter** + +The Re7 ALMM is designed with simplicity and performance in mind: + +* + **Focused on Ekubo liquidity pools** – ensures access to the highest APRs. + +* + **Active rebalancing in real time** – yield stays more optimized without relying on short-term incentives. + +* + **User-friendly experience** – deposit-and-earn model that requires no special knowledge. + +* + **Fully automated strategies** – no manual adjustments needed once you’ve deposited. + +## **Strengthening the Ecosystem** + +This launch is part of a broader effort to establish Starknet as the most capital-efficient DeFi ecosystem. By making sophisticated yield strategies accessible to everyday users, we are not only lowering barriers but also contributing to stronger liquidity and activity across the network. + +## **About Re7** + +Re7 Labs – a DeFi centric investment firm specialising in DeFi yield, liquid alpha strategies and on-chain vault management. With over 4 years of a consistent positive track record, Re7 is one of the most active DeFi liquidity providers globally, currently overseeing ~$1b. Re7 Labs is the innovation arm of Re7 Capital, focused on on-chain risk curation, vault management, and DeFi ecosystem design. Launched just over a year ago, it currently curates over $800 million in DeFi vaults across leading protocols. + +## **What’s Next** + +The **Re7 Labs | **ALMM** on Starknet** is now available – starknet.re7labs.xyz. + +Terms and Conditions apply, please review before engaging. + +--- +Sources: + - https://www.starknet.io/blog/starknet-foundation-introduces-btcfi-season/ +--- + +## BTCFi Season: 100M STRK Incentives on Starknet + +Home  /  Blog + +Oct 1, 2025 · 3 min read + +## Useful Resources + +* BTCFi Season’s official website +* BTCFi on Starknet + +## Introduction + +The Starknet Foundation is committed to Starknet’s emergence as the leading destination for sustainable yield on BTC. After months of careful research, planning, and design, the Starknet Foundation is proud to announce the launch of BTCFi Season, a program designed to set a BTC-centric DeFi flywheel in motion that will unlock productive capital flows on Starknet and ensure its long-term ecosystem growth. + +In Starknet’s case, lending and borrowing will be the cornerstone of the DeFi flywheel. That’s why enabling borrowing sits at the heart of BTCFi Season’s design, positioning Starknet to become the cheapest place to borrow stablecoins against BTC collateral. + +BTCFi Season is part of the broader BTCFi initiative on Starknet, which focuses on making BTC productive in DeFi with a strong emphasis on sustainability while upholding its core principles of security and decentralization. Other important Starknet launches under this initiative include Re7’s new BTC Yield Fund, BTC Staking, and StarkWare’s upcoming Earn – One-click Yield aggregator. + +## Program Details + +BTCFi Season was officially launched on **Tuesday, September 30th** by the Starknet Foundation. + +Participating protocols also launched their incentive programs on the same date. + +BTCFi Season is a structured incentive program supporting eligible ecosystem protocols that enable highly liquid BTC pools on DEXs and Money Markets and borrowing of stablecoins against BTC collateral. + +Starknet Foundation has dedicated a budget of 100M STRK to this program. + +The program is set to run for a minimum of six months, with the potential to continue well beyond that. + +## How the program works + +The Starknet Foundation has partnered with OpenBlock Labs to design a program for the fair and equitable allocation & distribution of STRK tokens to participating DeFi protocols. + +The program runs on a weekly cycle, with any significant changes taking effect at the start of a new cycle. + +### Allocations + +Protocol allocations are determined on a daily basis. The allocations are based on methodologies that factor in important protocol performance metrics. Methodologies are designed to be robust and resistant to manipulation while allowing for continuous adjustments if needed to stay aligned with the evolving needs and contributions of protocols within the ecosystem. + +### Distributions + +At the end of a cycle, daily protocol allocations of the last 7 days are aggregated and reviewed by OpenBlock Labs. Once finalized and communicated to all relevant parties, STRK allocations are distributed to the participating protocols by the Starknet Foundation. + +Each participating protocol to the program is responsible for designing, announcing and implementing their own incentive programs to reward their users with STRK. Each protocol may determine its own criteria for rewarding users, deciding both which users qualify and how rewards are allocated on eligible activity and assets/pairs. + +Each protocol will be responsible for its own distribution of STRK to its users. + +Users can begin claiming their allocations from participating protocols for the first cycle of the program starting Friday, October 10th. + +## What’s next? + +More eligible assets and pairs for BTCFi Season and more participating protocols. + +More ecosystem products that align with the vision of BTCFi on Starknet. Stay tuned for more! + +## FAQs + +## General + +* What is BTCFi Season? + + BTCFi Season is an incentive program launched by the Starknet Foundation to bootstrap BTC liquidity and stablecoin borrowing activity against BTC on Starknet. +* What is BTCFi Season’s purpose? + + BTCFi Season is an important piece of the broader BTCFi on Starknet initiative that is designed to enable the activities that will kickstart a flywheel effect for sustainable BTC yield -consistent, predictable and competitive, driven by real economic activity- and ecosystem growth on Starknet. +* Which DeFi verticals does BTCFi Season support? + + BTCFi Season supports the DEX and Money Market verticals. +* What activity will BTCFi Season support? + + BTCFi Season supports protocols that enable highly liquid BTC pools on DEXs and Money Markets and borrowing of stablecoins against BTC collateral. +* What assets and pairs will be eligible for incentives? + + You can find an updated list of eligible assets and pairs on BTCFi Season’s website. +* When does BTCFi Season launch? + + BTCFi Season launched on September 30th, 2025. +* How long will BTCFi Season last? + + The program is set to run for a minimum of six months, with the potential to continue well beyond that. + +## I am a User + +* How do I know if a project is a participating protocol in BTCFi Season and will be distributing STRK rewards? + + You can find an updated list of eligible protocols on BTCFi Season’s website. +* How do I know what actions are eligible for STRK rewards? + + You will need to explore the individual participating protocols and their terms of use to see how you can earn STRK through their programs. +* How can I claim my STRK from BTCFi Season? + + You will need to follow the guidelines provided from the individual participating protocols as they are responsible for their own distribution of STRK to their users based on their terms of use and announced programs. +* What happens if I don’t claim my STRK from BTCFi Season? + + You will be able to claim your STRK within each participating protocol. Any unclaimed STRK at the end of BTCFi Season will be returned back to the Foundation. + +## I am a Protocol + +* How can I participate in BTCFi Season? + + The Starknet Foundation determines the appropriateness of participating protocols in its absolute discretion and is focused solely on protocols that support the DEX and Money Market verticals. If you are interested in participating in BTCFi Season, please apply using this [form] and we will be in touch shortly. +* What criteria should I use for my incentive program? + + Each protocol shall determine its own criteria for rewarding users, deciding both which users qualify and how rewards are allocated on eligible activity and assets/pairs. +* Am I required to make the criteria of my incentive program public? + + Yes. Announcing your incentive program’s criteria and terms of use is a mandatory requirement to participate in BTCFi Season. + +## About the Starknet Foundation + +The Starknet Foundation is a non-profit organisation who oversees the growth and development of Starknet – a fast, scalable, future-proof, fully-verifiable tech platform. The Foundation oversees a broad range of educational, grant, and startup programs and partnerships that support developers and founders solving real world problems. + +The Starknet Foundation has allocated a total of 100 million STRK for BTCFi Season. + +## About OpenBlock Labs + +OpenBlock Labs is a quantitative research firm specializing in organic and sustainable ecosystem growth by providing data analytics and modeling to ensure that the chain is growing with real users. + +OpenBlock Labs will lead the recommendations of STRK allocations, the implementation and the analytics of the program. + +## Important Disclaimers & Disclosures + +The following disclaimers and risk disclosures apply: + +* The DeFi protocols mentioned in this blog post are independent from the Starknet Foundation and are not owned, operated or controlled by the Starknet Foundation. +* Users who engage with DeFi protocols do so at their own risk and subject to the terms and conditions set forth by each respective DeFi protocol. The Starknet Foundation has no relationship with the individual users. +* The Starknet Foundation does not endorse or recommend any specific DeFi protocol. Users are encouraged to conduct their own research and to exercise caution before engaging with any such protocol. +* Users are solely responsible for their own decisions and actions and assume all risks associated with utilising the respective DeFi Protocols. +* Users should be aware that DeFi, as a category, involves inherent financial risks, including the potential for total loss of invested assets. +* The Starknet Foundation disclaims any and all liability for losses that users may incur through their use of DeFi protocols. +* Users and DeFi Protocols are responsible for complying with any applicable laws, regulations, or restrictions applying to them in either availing of or providing DeFi services (as the case may be). +* The information provided in this post is for informational purposes only and should not be construed as financial, investment or legal advice. Users should consult with a qualified financial advisor before making any investment decisions. +* The Starknet Foundation reserves the right to discontinue BTCFi Season at any time. +* This blog should not be considered an offer to the public or to any particular DeFi protocol. + +--- +Sources: + - https://www.starknet.io/blog/starknet-x-bitcoin-the-next-step-btcfi-on-starknet/ +--- + +## BTCFi on Starknet: Bitcoin Staking & DeFi + +Home  /  Blog + +Sep 30, 2025 · 4 min read + +With Bitcoin and its asset BTC surging in discussions from Washington to Wall Street, Michael Saylor’s office, and events like Token2049 in Singapore, it’s time for a clear vision of Starknet’s role. + +What can a Layer 2 like Starknet offer BTC holders, whether institutions or individuals? How does it foster strong, decentralized systems for everyone? And how can this L2 scale Bitcoin, turning it into a true global settlement layer? After all, as BTC becomes the global reserve asset, it needs thriving financial markets. + +If this were a movie, the title would now read: Bitcoin Act II: The Starknet Edition. + +## Today: A Trilogy of Announcements + +Three key developments were announced today at Token2049 in Singapore. But first, some background. + +Back at the first Bitcoin conference in San Jose in 2013, Eli Ben-Sasson, now CEO of StarkWare, shared a pioneering vision: using zero-knowledge (ZK) tech to scale Bitcoin trustlessly and enable private transactions. + +Fast-forward to June 2024, the same cryptographer behind STARK cryptography (powering Starknet) outlined how Starknet could emphasise its focus on Bitcoin to realise that early vision. On March 2025 we officially declared that Starknet is planning to become Bitcoin’s execution layer. + +Today, after months of work from StarkWare developers, the community, and builders, we’re excited to unveil the next phase: BTCFi on Starknet. + +## BTCFi on Starknet – What just happened? + +**Detailed announcements on these initiatives, including tech specs and rollouts, will drop over the next 24 hours. Follow @Starknet on X for updates.** + +**1. BTC Staking –** For the first time, BTC holders can stake their BTC to secure a Layer 2 and earn rewards, all without losing custody. This launches on Starknet as the first fully trustless BTC staking on any L2. + +Every previous approach had tradeoffs like security risks, scalability issues, synthetic points systems, or lack of real economic activity. What launches today changes that. Bitcoin will be embedded into Starknet’s core security and consensus. BTC stakers will help secure the network and attest transactions in exchange for rewards. + +Starknet gains from BTC’s unmatched decentralization and security, while Bitcoiners put their sats to work. Starknet’s staking is already proven, with ~65k delegators, ~150 validators, and over 575m STRK staked. + +**2. Key Contributors** – Contributors like WBTC, Lombard, Solv, and Threshold Network are making BTCFi on Starknet real, easing BTC’s use in DeFi and cross-chain access. Non-Bitcoin-native players like LayerZero, Hyperlane, Rhino.Fi, Atomiq, and Garden enable smooth cross-chain flows. Pragma, Starknet’s native oracle provider, has been contributing on multiple fronts, from price feed infrastructure, to structured products, with automated trading strategies run by its asset management arm, 0D Capital. + +Re7 Capital – who operate a Cayman fund with $1B+ AUM fund and managed by FCA and CIMA regulated investment managers, is an early ecosystem investor. Like Multicoin and Jump Capital did for Solana, Re7 is building momentum and infrastructure on Starknet. We’re excited to work with them as Starknet grows. + +Their new BTC-denominated yield fund advances institutional BTC deployment and shares our vision for BTC’s future with more utility and functionality. + +**3. 100M STRK Incentives** – to affirm BTC’s status as a pristine asset, the Starknet Foundation is launching a 100 million STRK incentives program (“BTCFi Season”) to boost the BTCFi ecosystem on Starknet. + +This program will distribute 100 million STRK to kick start the BTCFi flywheel, making Starknet the most affordable place to borrow stables against BTC and fueling yield strategies like tokenised basis trades, RWAs and more. + +## Our Broader Blockchain Values + +These steps empower individuals and institutions to activate their BTC. Ultimately, this strengthens decentralised systems for a more equitable, integrity-driven future. + +Whether via direct staking of BTC, or participation in other initiatives such as Re7’s, when any amount of BTC arrives on Starknet, something unique is happening. The holder is earning yield from one chain’s asset (BTC) while helping secure another. + +While headlines emphasise BTC as just a store of value (like Saylor’s focus), we believe the emerging global reserve asset requires real utility and secure and robust financial markets. + +## Security + +Starknet handles BTC transparently through auditable protocols, avoiding opacity or hidden leverage. Our zk-STARK proofs are post-quantum secure and require no trusted setup-the only ZK-Rollup in production with this guarantee. We are the only ZK/Validity Rollup confirmed by L2Beat as Stage 1. This same technology class, via the permissioned StarkEx systems that preceded the permissionless Starknet, has secured over $1.38 trillion in cumulative trading volume, $206 million in total value locked, more than 1.06 billion transactions, and 219 million NFTs. + +## Making Starknet the Execution Layer for Bitcoin + +We’ll dive deeper into the three developments over the next day. + +But first, a word on Part 2 of the Bitcoin-Starknet story. The main focus of today’s developments is bringing Bitcoin to Starknet. + +The Bitcoin economy on Starknet is the vital first step, unlocking true utility for BTC holders to earn yield and join DeFi without sacrificing security or decentralisation. + +We’re also advancing our other efforts towards the end goal – becoming Bitcoin’s execution layer. Using Circle STARKs, we’ve verified Bitcoin’s full header chain in 25 milliseconds on a Raspberry Pi. Our decentralisation roadmap is on schedule. We are the first L2 to launch decentralised sequencers. We are also in close collaboration with the leading BitVM teams on the frontier of Bitcoin scaling research and development. + +Our vision is accelerating toward a scaled, unified Bitcoin ecosystem with Starknet as its high performance engine. + +Watch for more updates on each of these initiatives soon! + +--- +Sources: + - https://www.starknet.io/blog/starknet-alpen-bitcoin-glock/ +--- + +## Starknet x Alpen: Powering BTCFi with the Most Trustless Bitcoin Bridge | Starknet + +Home  /  Blog + +Oct 15, 2025 · 2 min read + +We are excited to announce a new collaboration with Alpen Labs who are building the most trust-minimized possible bridge between Bitcoin and Starknet. This is exciting news for Bitcoin holders seeking yield opportunities with their BTC without compromising security and custody. It also marks a major milestone in Starknet’s journey to become the Bitcoin DeFi layer, enabling Bitcoin users to put their BTC to work in DeFi in the most trust-minimized way possible. + +## Why Glock? + +Glock lies at the forefront of Bitcoin scaling research and enabling Bitcoin L2s. Building on the Alpen Labs team’s foundational work on BitVM and Bitcoin verification research, Glock represents the next generation of trust-minimized architecture. In essence, Glock defers computation from Bitcoin network itself to offchain entities. This design drastically reduces on-chain overhead, allowing for complex spending conditions on BTC without hitting existing Script limits. With Glock bridges, we can lock BTC on Bitcoin in a way that allows unlocking them only if they were burned on another chain. Unlike the multisig-based bridges that exist today, with Glock we can actually check these conditions on BTC rather than rely on mere attestations. + +This more secure method of bridging BTC into Starknet will unlock a wide range of use cases for Bitcoin holders, from BTCFi opportunities to payments at scale, all in the most trustless way possible. We are constantly looking for ways to increase Bitcoin’s utility and usability without changing Bitcoin itself and we believe that the Glock approach is the right one in order to achieve that. + +## Starknet as a trust-minimized execution layer on Bitcoin + +Strata serves as the layer securing BTC deposits to the Alpen EVM chain. Together with Alpen, we aim to make Starknet an additional execution layer for Strata. This means that the same security assumptions will apply to moving BTC to either Alpen or Starknet. This will enable builders and users to choose the execution layer that best fits their needs.  + +## What’s next? + +Alpen is finalizing Glock, the groundbreaking verification protocol based on garbled circuits that dramatically reduces the protocol’s on-chain footprint. Starknet and Alpen will be the first chains to adopt Glock for secure BTC bridging which will enable interoperability between them. + +Building more secure bridges from Bitcoin is a challenging journey that requires deep research and innovation. Yet with every step taken alongside Alpen, we move closer to a future where Bitcoin’s unmatched security anchors a thriving, interoperable financial ecosystem. Starknet stands ready to lead the way. Stay tuned. + +--- +Sources: + - https://www.starknet.io/blog/native-usdc-cctp-v2-coming-to-starknet/ +--- + +## Native USDC & CCTP V2 Coming to Starknet | Starknet + +Home  /  Blog + +Oct 23, 2025 · 2 min read + +### **A Major Leap for Starknet DeFi** + +In the coming weeks, Starknet DeFi is entering a new era. With the upcoming launch of native USDC and CCTP V2, the network will gain access to the world’s largest regulated stablecoin\* and secure cross-chain transfers with CCTP V2. It’s a milestone that makes Starknet’s stablecoin infrastructure even more composable. Starknet currently supports Bridged USDC (USDC.e), a bridged, wrapped version, depending on third-party contracts. The Starknet team will work with ecosystem apps to smoothly migrate liquidity from bridged USDC to native USDC over time. There will be no immediate impact to existing bridges and they will continue to operate as usual. Bridged USDC will remain clearly labeled as “USDC.e” in block explorers, app interfaces, and documentation. + +With native USDC, issued through regulated affiliates of Circle, instead of locking tokens on one chain and minting a synthetic version on another, transfers now use a burn-and-mint model. When USDC moves between Starknet and other CCTP V2-supported blockchains, it’s burned on the source and minted on the destination. No middlemen, no wrapped assets, and no extra layers of trust. + +## **Why This Matters for Users** + +For users, native USDC means a safer, simpler, and faster experience. Bridging USDC to and from Starknet becomes seamless. Capital moves fluidly, without the friction or risk that comes with traditional bridging models, and users benefit from institutional-grade security and transparency. Native USDC also directly strengthens Starknet’s BTCFi flywheel. As Bitcoin-based liquidity flows into Starknet through bridges and protocols, native USDC provides a stable and trusted counterweight for trading, lending, and yield strategies. With native USDC in the mix, BTCFi protocols can pair Bitcoin assets with deep, onchain dollar liquidity, creating more efficient markets and improving price stability. This tighter integration of BTC and stablecoin liquidity accelerates Starknet’s growth as the leading home for Bitcoin-based DeFi on Ethereum. + +## **What’s Next?** + +Over the coming weeks, the Starknet community will coordinate a smooth transition from USDC.e to native USDC. Users will migrate balances, while protocols, wallets, and custodians update integrations to support the new standard. The arrival of native USDC signals the next stage of growth for the Starknet ecosystem, one defined by deeper liquidity and simpler user flows. + +\*USDC is issued by Circle’s regulated affiliates. A list of Circle’s regulatory authorizations can be found here. diff --git a/python/src/scripts/summarizer/generated/cairo_book_summary.md b/python/src/cairo_coder_tools/ingestion/generated/cairo_book_summary.md similarity index 100% rename from python/src/scripts/summarizer/generated/cairo_book_summary.md rename to python/src/cairo_coder_tools/ingestion/generated/cairo_book_summary.md diff --git a/python/src/scripts/summarizer/generated/corelib_summary.md b/python/src/cairo_coder_tools/ingestion/generated/corelib_summary.md similarity index 100% rename from python/src/scripts/summarizer/generated/corelib_summary.md rename to python/src/cairo_coder_tools/ingestion/generated/corelib_summary.md diff --git a/python/src/scripts/summarizer/header_fixer.py b/python/src/cairo_coder_tools/ingestion/header_fixer.py similarity index 100% rename from python/src/scripts/summarizer/header_fixer.py rename to python/src/cairo_coder_tools/ingestion/header_fixer.py diff --git a/python/src/scripts/summarizer/mdbook_summarizer.py b/python/src/cairo_coder_tools/ingestion/mdbook_summarizer.py similarity index 100% rename from python/src/scripts/summarizer/mdbook_summarizer.py rename to python/src/cairo_coder_tools/ingestion/mdbook_summarizer.py diff --git a/python/src/scripts/summarizer/summarizer_factory.py b/python/src/cairo_coder_tools/ingestion/summarizer_factory.py similarity index 100% rename from python/src/scripts/summarizer/summarizer_factory.py rename to python/src/cairo_coder_tools/ingestion/summarizer_factory.py diff --git a/python/src/scripts/README.md b/python/src/scripts/README.md new file mode 100644 index 00000000..c985de49 --- /dev/null +++ b/python/src/scripts/README.md @@ -0,0 +1,164 @@ +# Cairo Coder Scripts + +This directory contains the main CLI entrypoints for Cairo Coder workflows. All business logic has been moved to the `cairo_coder` library package for better maintainability and reusability. + +## Available Commands + +Cairo Coder provides three main CLI tools for different workflows: + +### 1. `eval` - Evaluation Tool + +Evaluate Cairo Coder's performance using various test suites. + +```bash +# Run Starklings evaluation +uv run eval --runs 3 --output-dir ./results + +# Evaluate specific category +uv run eval --category "intro" --max-concurrent 5 + +# Full options +uv run eval --help +``` + +**Key Features:** +- Evaluates Cairo Coder against Starklings exercises +- Generates detailed reports with success rates +- Supports concurrent evaluation for speed +- Configurable API endpoints and models + +### 2. `ingest` - Data Ingestion Tool + +Ingest documentation from various sources into a format suitable for the RAG pipeline. + +```bash +# Ingest from a Git repository +uv run ingest from-git https://github.com/cairo-book/cairo-book \ + --type mdbook \ + --output cairo_book_summary.md + +# Crawl a website using predefined target (automatically filters for 2025) +uv run ingest from-web starknet-blog-2025 + +# Or crawl manually with custom filter +uv run ingest from-web https://www.starknet.io/blog \ + --content-filter="2025" \ + --output starknet_blog_2025.md + +# Fix markdown headers +uv run ingest fix-headers input.md --output output.md + +# List available options +uv run ingest list-targets +uv run ingest list-types +``` + +**Key Features:** +- Git repository ingestion with LLM summarization +- Web crawling with filtering capabilities +- Support for mdbook and other documentation types +- Header fixing utilities for better formatting + +### 3. `dataset` - Dataset Management Tool + +Extract, generate, and analyze datasets for Cairo Coder. + +```bash +# Extract QA pairs from LangSmith exports +uv run dataset extract starknet-agent \ + --input export.jsonl \ + --output qa_pairs.json + +uv run dataset extract cairo-coder \ + --input traces.jsonl \ + --output pairs.json \ + --only-generated-answers + +# Generate synthetic datasets +uv run dataset generate starklings \ + --output starklings_dataset.json + +# Analyze a dataset with LLM +uv run dataset analyze \ + --input qa_pairs.json \ + --output analysis.json \ + --model "openrouter/x-ai/grok-4-fast:free" +``` + +**Key Features:** +- Extract QA pairs from various export formats +- Generate datasets from Starklings exercises +- LLM-powered dataset analysis +- De-duplication and filtering + +## Architecture + +The refactored architecture follows these principles: + +1. **Separation of Concerns**: Business logic lives in `cairo_coder/`, scripts are just thin entrypoints +2. **Workflow-Oriented**: Commands are organized by workflow (eval, ingest, dataset) not by implementation +3. **Reusability**: All logic can be imported and used programmatically + +### Directory Structure + +``` +python/src/ +├── cairo_coder/ # Main library package +│ ├── dspy/ # DSPy RAG pipeline +│ ├── server/ # FastAPI server +│ ├── datasets/ # Dataset extractors (existing) +│ └── ... +├── cairo_coder_tools/ # Tools library package +│ ├── evals/ # Evaluation logic +│ │ └── starklings/ # Starklings evaluation suite +│ ├── ingestion/ # Data ingestion logic +│ │ ├── crawler.py # Web crawler +│ │ └── ... # Summarizers, etc. +│ └── datasets/ # Dataset analysis utilities +│ └── analysis.py # LLM-based analysis +└── scripts/ # CLI entrypoints only + ├── eval.py # Evaluation CLI + ├── ingest.py # Ingestion CLI + └── dataset.py # Dataset CLI +``` + +## Migration Guide + +If you were using the old scripts, here's how to migrate: + +| Old Command | New Command | +|------------|-------------| +| `uv run starklings_evaluate` | `uv run eval` | +| `uv run cairo-coder-summarize` | `uv run ingest from-git` | +| `uv run docs-crawler` | `uv run ingest from-web` | +| `uv run filter_2025_blogs` | `uv run ingest from-web starknet-blog-2025` | +| `uv run cairo-coder-datasets extract` | `uv run dataset extract` | +| `uv run cairo-coder-datasets generate` | `uv run dataset generate` | +| N/A | `uv run dataset analyze` (new!) | + +## Getting Help + +Each command has detailed help text: + +```bash +uv run eval --help +uv run ingest --help +uv run dataset --help +``` + +For subcommands: + +```bash +uv run ingest from-git --help +uv run dataset extract --help +``` + +## Development + +To add new functionality: + +1. Add the core logic to the appropriate module in `cairo_coder/` +2. Add a new subcommand or option to the relevant CLI in `scripts/` +3. Update this README + +This keeps the codebase maintainable and testable. diff --git a/python/src/scripts/README_starklings_evaluation.md b/python/src/scripts/README_starklings_evaluation.md deleted file mode 100644 index 0c5c3be0..00000000 --- a/python/src/scripts/README_starklings_evaluation.md +++ /dev/null @@ -1,168 +0,0 @@ -# Starklings Evaluation Script - -A Python script for evaluating Cairo Coder's ability to solve Starklings exercises. This script automates the process of testing code generation quality by having the Cairo Coder solve programming exercises and verifying compilation. - -## Features - -- **Automated Exercise Evaluation**: Processes all Starklings exercises automatically -- **Category Filtering**: Evaluate specific exercise categories -- **Multiple Runs**: Support for multiple evaluation runs to measure consistency -- **Comprehensive Reports**: JSON and Markdown reports with detailed metrics -- **Concurrent Processing**: Efficient parallel API calls with rate limiting -- **Debug Output**: Saves generated code and errors for analysis -- **Flexible Configuration**: Environment variables and CLI options - -## Installation - -The script uses existing Cairo Coder dependencies. Ensure you have: - -1. Cairo Coder backend running (`pnpm dev` in the main project) -2. Python environment with required packages -3. Scarb installed for Cairo compilation - -## Usage - -### Basic Usage - -```bash -# Run evaluation with default settings -uv run starklings_evaluate - -# Run 5 evaluation runs -uv run starklings_evaluate --runs 5 - -# Evaluate only "intro" category -uv run starklings_evaluate --category intro - -# Verbose output -uv run starklings_evaluate --verbose -``` - -### CLI Options - -```bash -Options: - -r, --runs INTEGER Number of evaluation runs to perform [default: 1] - -c, --category TEXT Filter exercises by category - -o, --output-dir PATH Output directory for results [default: ./starklings_results] - -a, --api-endpoint TEXT Cairo Coder API endpoint [default: http://localhost:3001] - -m, --model TEXT Model name to use [default: cairo-coder] - -s, --starklings-path PATH Path to Starklings repository [default: ./starklings-cairo1] - --max-concurrent INTEGER Maximum concurrent API calls [default: 5] - --timeout INTEGER API timeout in seconds [default: 120] - -v, --verbose Enable verbose logging - --help Show this message and exit. -``` - -## Output Structure - -```bash -starklings_results/ -└── run_20240117_143022/ - ├── starklings_run_1_20240117_143022.json # Individual run report - ├── starklings_run_2_20240117_143122.json # (if multiple runs) - ├── starklings_consolidated_report.json # Combined results - ├── starklings_summary.md # Human-readable summary - └── debug/ - ├── intro1_generated.cairo # Generated solutions - ├── intro1_error.txt # Errors (if any) - └── ... -``` - -## Report Format - -### Consolidated Report (JSON) - -```json -{ - "total_runs": 3, - "overall_success_rate": 0.85, - "timestamp": "2024-01-17T14:30:22", - "exercise_summary": { - "intro": { - "intro1": { - "success_count": 3, - "total_runs": 3, - "success_rate": 1.0 - } - } - }, - "runs": [...] -} -``` - -### Summary Report (Markdown) - -- Overall success rates -- Category breakdowns -- Exercise-level statistics -- Individual run details - -## Implementation Details - -### Architecture - -```bash -starklings_evaluation/ -├── __init__.py -├── models.py # Data structures -├── api_client.py # Cairo Coder API client -├── evaluator.py # Core evaluation logic -├── report_generator.py # Report generation -└── config.py # Configuration handling -``` - -### Key Components - -1. **StarklingsEvaluator**: Main evaluation orchestrator -2. **CairoCoderAPIClient**: Async HTTP client for API calls -3. **ReportGenerator**: JSON and Markdown report generation -4. **Data Models**: Type-safe result structures - -### Integration Points - -- Uses existing `starklings_helper.py` for exercise parsing -- Leverages `utils.py` for code extraction and compilation -- Compatible with existing runner-crate infrastructure - -## Comparison with Original Script - -This Python implementation maintains compatibility with the original JavaScript version while adding: - -- Better error handling and recovery -- Structured data models with type safety -- Async/concurrent processing -- More detailed debug output -- Flexible configuration options - -## Troubleshooting - -### Common Issues - -1. **API Connection Failed** - - - Ensure Cairo Coder backend is running - - Check API endpoint configuration - -2. **Starklings Repository Not Found** - - - Script will automatically clone the repository - - Ensure git is installed and accessible - -3. **Compilation Failures** - - Check Scarb installation - - Verify runner-crate fixtures are present - -### Debug Mode - -Use `--verbose` flag for detailed logging: - -```bash -uv run starklings_evaluate --verbose -``` - -Check debug files in output directory for: - -- Generated code for each exercise -- Detailed error messages -- API response data diff --git a/python/src/scripts/datasets/cli.py b/python/src/scripts/dataset.py similarity index 77% rename from python/src/scripts/datasets/cli.py rename to python/src/scripts/dataset.py index 97f5c589..87b2bc09 100644 --- a/python/src/scripts/datasets/cli.py +++ b/python/src/scripts/dataset.py @@ -1,4 +1,9 @@ -from __future__ import annotations +#!/usr/bin/env python3 +"""Dataset CLI for Cairo Coder. + +This module provides commands for extracting, generating, and analyzing datasets +for use with Cairo Coder. +""" import asyncio import json @@ -8,13 +13,16 @@ import typer from typer.core import TyperGroup -from cairo_coder.datasets.extractors import ( +from cairo_coder_tools.datasets.extractors import ( extract_cairocoder_pairs, extract_starknet_agent_pairs, ) +from cairo_coder_tools.datasets.analysis import analyze_dataset class HelpOnInvalidCommand(TyperGroup): + """Custom typer group that shows help on invalid commands.""" + def get_command(self, ctx, cmd_name): # type: ignore[override] cmd = super().get_command(ctx, cmd_name) if cmd is None: @@ -148,7 +156,7 @@ def extract_cairo_coder( help="Write only queries as a JSON array instead of [{query, answer}] objects.", ), ) -> None: - """Extract QA pairs from a Cairo-Coder LangSmith export with `outputs.output`. + """Extract QA pairs from a Cairo-Coder LangSmith export. If neither filtering flag is used, extracts all matching records. """ @@ -228,5 +236,62 @@ def generate_starklings( typer.echo(f"Generated {len(examples)} examples to {output}") +@app.command("analyze") +def analyze( + input: Path = typer.Option( + Path("qa_pairs.json"), + "--input", + "-i", + help="Path to the input dataset JSON file", + ), + output: Path = typer.Option( + Path("analysis.json"), + "--output", + "-o", + help="Path to save the analysis results", + ), + model: str = typer.Option( + "openrouter/x-ai/grok-4-fast:free", + "--model", + "-m", + help="Language model to use for analysis", + ), + max_tokens: int = typer.Option( + 30000, + "--max-tokens", + help="Maximum tokens for the LLM response", + ), +) -> None: + """Analyze a dataset of question-answer pairs using an LLM. + + This command uses an LLM to analyze the dataset and provide insights about: + - Languages used in queries + - Common topics and question categories + - Overall quality and patterns in the dataset + """ + typer.echo(f"Analyzing dataset from {input}...") + typer.echo(f"Using model: {model}") + + try: + result = analyze_dataset( + dataset_path=input, + output_path=output, + lm_model=model, + max_tokens=max_tokens, + ) + + typer.echo(typer.style("✓ Analysis complete!", fg=typer.colors.GREEN)) + typer.echo(f"Results saved to: {output}") + typer.echo(f"\nFound {len(result.get('languages', []))} languages") + typer.echo(f"Identified {len(result.get('topics', []))} topic categories") + + except Exception as e: + import traceback + + traceback.print_exc() + typer.echo(typer.style(f"✗ Error: {str(e)}", fg=typer.colors.RED), err=True) + raise typer.Exit(code=1) from e + + if __name__ == "__main__": app() diff --git a/python/src/scripts/starklings_evaluate.py b/python/src/scripts/eval.py old mode 100755 new mode 100644 similarity index 91% rename from python/src/scripts/starklings_evaluate.py rename to python/src/scripts/eval.py index a23d1ce9..2c04e1e9 --- a/python/src/scripts/starklings_evaluate.py +++ b/python/src/scripts/eval.py @@ -1,8 +1,8 @@ #!/usr/bin/env python3 -"""Starklings evaluation script for testing Cairo code generation. +"""Evaluation CLI for Cairo Coder. -This script evaluates the Cairo Coder's ability to solve Starklings exercises -by generating solutions and testing if they compile successfully. +This module provides commands for evaluating Cairo Coder's performance +using various test suites and datasets. """ import asyncio @@ -14,12 +14,11 @@ import click import structlog -# Add parent directory to path for imports -sys.path.insert(0, str(Path(__file__).parent.parent)) - -from scripts.starklings_evaluation.evaluator import StarklingsEvaluator -from scripts.starklings_evaluation.models import ConsolidatedReport -from scripts.starklings_evaluation.report_generator import ReportGenerator +from cairo_coder_tools.evals.starklings import ( + ConsolidatedReport, + ReportGenerator, + StarklingsEvaluator, +) # Configure structured logging structlog.configure( @@ -79,7 +78,7 @@ def main( max_concurrent: int, timeout: int, verbose: bool, -): +) -> None: """Evaluate Cairo Coder on Starklings exercises.""" logger.info( "Starting Starklings evaluation", @@ -135,7 +134,7 @@ async def run_evaluation( starklings_path: Path, max_concurrent: int, timeout: int, -): +) -> None: """Run the evaluation process.""" # Create output directory diff --git a/python/src/scripts/filter_2025_blogs.py b/python/src/scripts/filter_2025_blogs.py deleted file mode 100644 index 22066ef2..00000000 --- a/python/src/scripts/filter_2025_blogs.py +++ /dev/null @@ -1,147 +0,0 @@ -#!/usr/bin/env python3 -""" -Filter doc_dump.md to keep only blog entries published in 2025. - -Reads the doc_dump.md file, identifies individual pages separated by "---", -and filters to keep only those containing blog entries with 2025 dates. -""" - -import re -from pathlib import Path - - -def is_2025_blog_entry(content: str) -> bool: - """ - Check if content contains a blog entry from 2025. - - Looks for patterns like: - Home / Blog - Feb 5, 2023 · 2 min read - - Returns True if the date is from 2025. - """ - # Look for the blog pattern with date - # Pattern: Month Day, Year · time min read - blog_pattern = r'Home\s+/\s+Blog.*?(\w+\s+\d+,\s+(\d{4}))\s+·' - - matches = re.findall(blog_pattern, content, re.DOTALL | re.IGNORECASE) - - for match in matches: - year = match[1] - if year == '2025': - return True - - return False - - -def filter_doc_dump(input_file: Path, output_file: Path): - """ - Read doc_dump.md and filter to keep only 2025 blog entries. - Supports both old format (single Sources block) and new format (individual Sources blocks). - """ - with open(input_file, encoding='utf-8') as f: - content = f.read() - - filtered_pages = [] - total_pages = 0 - kept_pages = 0 - document_header = "" - - # Try new format first (individual Sources blocks) - page_pattern = r'(---\s*\nSources:\s*\n\s*-\s*[^\n]+\n---\s*\n+##[^#].*?)(?=\n---\s*\nSources:|\Z)' - matches = list(re.finditer(page_pattern, content, re.DOTALL)) - - if matches: - # New format detected - print("Detected new format (individual Sources blocks)") - - # Keep document header if present - header_match = re.match(r'^(.*?)(?=\n---\s*\nSources:)', content, re.DOTALL) - document_header = header_match.group(1).strip() if header_match else "" - - for match in matches: - page = match.group(1) - if not page.strip(): - continue - - total_pages += 1 - - # Check if this is a 2025 blog entry - if is_2025_blog_entry(page): - filtered_pages.append(page.strip()) - kept_pages += 1 - - # Extract URL for logging (from Sources block) - url_match = re.search(r'Sources:\s*\n\s*-\s*(.+)', page) - if url_match: - print(f"Keeping: {url_match.group(1)}") - else: - # Fall back to old format (**Source URL:** markers) - print("Detected old format (**Source URL:** markers)") - - pattern = re.compile(r'^\*\*Source URL:\*\*\s+(\S+)', re.MULTILINE) - page_matches = list(pattern.finditer(content)) - - for i, m in enumerate(page_matches): - url = m.group(1) - start = m.end() - end = page_matches[i + 1].start() if i + 1 < len(page_matches) else len(content) - page_content = content[start:end].strip() - - # Remove surrounding '---' separators - lines = page_content.splitlines() - while lines and lines[0].strip() == '---': - lines.pop(0) - while lines and lines[-1].strip() == '---': - lines.pop() - page_content = "\n".join(lines).strip() - - total_pages += 1 - - if is_2025_blog_entry(page_content): - # Convert to new format - new_format_page = f"---\nSources:\n - {url}\n---\n\n{page_content}" - filtered_pages.append(new_format_page) - kept_pages += 1 - print(f"Keeping: {url}") - - # Construct output with header and filtered pages - output_parts = [] - if document_header: - output_parts.append(document_header) - output_parts.append("") - output_parts.append("") - - output_parts.extend(filtered_pages) - output_content = '\n\n'.join(output_parts) - - # Write to output file - with open(output_file, 'w', encoding='utf-8') as f: - f.write(output_content) - - print(f"\n{'-'*60}") - print(f"Total pages processed: {total_pages}") - print(f"Pages kept (2025 blogs): {kept_pages}") - print(f"Pages removed: {total_pages - kept_pages}") - print(f"Output written to: {output_file}") - - -def main(): - # Paths - script_dir = Path(__file__).parent - python_dir = script_dir.parent.parent - input_file = python_dir / "doc_dump.md" - output_file = python_dir / "doc_dump_2025_blogs.md" - - if not input_file.exists(): - print(f"Error: Input file not found: {input_file}") - return - - print(f"Reading from: {input_file}") - print("Filtering for 2025 blog entries...\n") - - filter_doc_dump(input_file, output_file) - - -if __name__ == "__main__": - main() diff --git a/python/src/scripts/ingest.py b/python/src/scripts/ingest.py new file mode 100644 index 00000000..8b1dbae6 --- /dev/null +++ b/python/src/scripts/ingest.py @@ -0,0 +1,407 @@ +#!/usr/bin/env python3 +"""Data ingestion CLI for Cairo Coder. + +This module provides commands for ingesting documentation from various sources +into a format suitable for the RAG pipeline. +""" + +import asyncio +import re +import resource +from enum import Enum +from pathlib import Path +from typing import Optional + +import structlog +import typer +from dotenv import load_dotenv + +from cairo_coder_tools.ingestion.base_summarizer import SummarizerConfig +from cairo_coder_tools.ingestion.crawler import DocsCrawler +from cairo_coder_tools.ingestion.header_fixer import HeaderFixer +from cairo_coder_tools.ingestion.summarizer_factory import DocumentationType, SummarizerFactory + + +def is_2025_blog_entry(content: str) -> bool: + """Check if content is a blog entry from 2025. + + Looks for patterns like: + Home / Blog + Apr 3, 2025 · 3 min read + OR + Home / Blog + Share this post: + Jul 29, 2025 + """ + import re + + # Pattern 1: Month Day, Year · X min read + # Example: "Apr 3, 2025 · 3 min read" + pattern1 = r'Home\s+/\s+Blog.*?(\w+\s+\d+,\s+(\d{4}))\s*·' + + # Pattern 2: Month Day, Year (without the · min read) + # Example: "Jul 29, 2025" after "Share this post:" + pattern2 = r'Home\s+/\s+Blog.*?Share this post:.*?(\w+\s+\d+,\s+(\d{4}))' + + # Pattern 3: Just Month Day, Year with min read + # Example: "Nov 26, 2024 · 3 min read" + pattern3 = r'(\w+\s+\d+,\s+(\d{4}))\s*·.*?min read' + + for pattern in [pattern1, pattern2, pattern3]: + matches = re.findall(pattern, content, re.DOTALL | re.IGNORECASE) + for match in matches: + year = match[1] if len(match) > 1 else match[-1] + if year == '2025': + return True + + return False + + +def clean_blog_content(content: str) -> str: + """Remove unwanted sections from blog content. + + Removes: + - "Join our newsletter" section and its content + - "May also interest you" section and its content + """ + import re + + # Remove "Join our newsletter" section and everything after it until next header + # Match any header level (##, ###, ####, etc.) + content = re.sub( + r'^#{2,}\s*Join our newsletter.*?(?=^#{2,}|\Z)', + '', + content, + flags=re.DOTALL | re.IGNORECASE | re.MULTILINE + ) + + # Remove "May also interest you" section and everything after it + # Match any header level (##, ###, ####, etc.) + content = re.sub( + r'^#{2,}\s*May also interest you.*?(?=^#{2,}|\Z)', + '', + content, + flags=re.DOTALL | re.IGNORECASE | re.MULTILINE + ) + + # Also try to catch variations without markdown headers (plain text) + content = re.sub( + r'Join our newsletter.*?(?=\n\n[A-Z]|\Z)', + '', + content, + flags=re.DOTALL | re.IGNORECASE + ) + + content = re.sub( + r'May also interest you.*?(?=\n\n[A-Z]|\Z)', + '', + content, + flags=re.DOTALL | re.IGNORECASE + ) + + # Clean up multiple newlines + content = re.sub(r'\n{3,}', '\n\n', content) + + return content.strip() + +# Load environment variables +load_dotenv() + +logger = structlog.get_logger(__name__) + +app = typer.Typer(help="Cairo Coder Documentation Ingestion CLI") + + +class TargetRepo(str, Enum): + """Predefined target repositories for Git ingestion""" + + CORELIB_DOCS = "https://github.com/starkware-libs/cairo-docs" + CAIRO_BOOK = "https://github.com/cairo-book/cairo-book" + # Add more repositories as needed + + +class TargetWebsite(str, Enum): + """Predefined target websites for web crawling""" + + STARKNET_BLOG_2025 = "https://www.starknet.io/blog" + # Add more websites as needed + + +@app.command(name="from-git") +def from_git( + repo_url: str = typer.Argument(help="GitHub repository URL to summarize."), + doc_type: DocumentationType = typer.Option( + DocumentationType.MDBOOK, "--type", "-t", help="Documentation type" + ), + branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Git branch to use"), + subdirectory: Optional[str] = typer.Option( + None, "--subdirectory", "-s", help="Subdirectory to use" + ), + output: Path = typer.Option(Path("summary.md"), "--output", "-o", help="Output file path"), + verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose output"), +) -> None: + """Ingest documentation from a Git repository. + + Clones a Git repository, builds the documentation (if needed), and generates + a consolidated summary using LLM-based summarization. + """ + + # Set file descriptor limit for the current process + try: + current_soft, current_hard = resource.getrlimit(resource.RLIMIT_NOFILE) + new_limit = min(4096, current_hard) # Don't exceed hard limit + resource.setrlimit(resource.RLIMIT_NOFILE, (new_limit, current_hard)) + logger.info(f"Raised file descriptor limit from {current_soft} to {new_limit}") + except (ValueError, OSError) as e: + logger.warning(f"Could not raise file descriptor limit: {e}") + logger.warning( + "You may want to run 'ulimit -n 4096' in your terminal before running this script" + ) + + # Check for predefined targets + if repo_url.upper().replace("-", "_") in [t.name for t in TargetRepo]: + target = TargetRepo[repo_url.upper().replace("-", "_")] + repo_url = target.value + if verbose: + typer.echo(f"Using predefined target: {target.name} -> {repo_url}") + + # Create configuration + config = SummarizerConfig( + repo_url=repo_url, branch=branch, subdirectory=subdirectory, output_path=output + ) + + # Create and run summarizer + try: + typer.echo(f"Creating {doc_type.value} summarizer for {repo_url}...") + summarizer = SummarizerFactory.create(doc_type, config) + + typer.echo("Processing documentation...") + if verbose: + typer.echo(f" - Cloning from branch: {branch}") + typer.echo(f" - Output will be saved to: {output}") + + output_path = summarizer.process() + + typer.echo( + typer.style(f"✓ Summary successfully generated at: {output_path}", fg=typer.colors.GREEN) + ) + + except Exception as e: + import traceback + + traceback.print_exc() + typer.echo(typer.style(f"✗ Error: {str(e)}", fg=typer.colors.RED), err=True) + raise typer.Exit(code=1) from e + + +@app.command(name="from-web") +def from_web( + url: str = typer.Argument(help="Base URL of website to crawl, or predefined target name."), + output: Path = typer.Option(Path("doc_dump.md"), "--output", "-o", help="Output file path"), + content_filter: Optional[str] = typer.Option( + None, + "--content-filter", + "-f", + help="Filter content by this string (e.g., '2025' to only keep pages containing '2025')", + ), + include_patterns: Optional[str] = typer.Option( + None, + "--include-patterns", + "-i", + help="Comma-separated regex patterns for URLs to include (e.g., '/blog/,/docs/')", + ), +) -> None: + """Ingest documentation from a website by crawling. + + Crawls a documentation website starting from the base URL, extracts content, + and compiles it into a single markdown file. + + Examples: + # Use predefined target for StarkNet 2025 blog posts + uv run ingest from-web starknet-blog-2025 --output starknet_blog_2025.md + + # Crawl StarkNet blog manually with filter + uv run ingest from-web https://www.starknet.io/blog --content-filter="2025" + + # Crawl docs with URL filtering + uv run ingest from-web https://example.com --include-patterns="/docs/,/api/" + """ + + # Check for predefined website targets + actual_url = url + auto_filter_func = None + auto_processor_func = None + auto_exclude_patterns = None + auto_output = None + + if url.upper().replace("-", "_") in [t.name for t in TargetWebsite]: + target = TargetWebsite[url.upper().replace("-", "_")] + actual_url = target.value + + # Apply automatic settings for specific targets + if target == TargetWebsite.STARKNET_BLOG_2025: + auto_filter_func = is_2025_blog_entry + auto_processor_func = clean_blog_content + auto_exclude_patterns = [r'video\/$'] # Exclude URLs ending with video/ + auto_output = Path("starknet_blog_2025.md") + typer.echo(f"Using predefined target: {target.name.lower().replace('_', '-')}") + typer.echo(f" URL: {actual_url}") + typer.echo(f" Auto-filter: 2025 blog entries") + typer.echo(f" Auto-cleanup: Removing newsletter and interest sections") + typer.echo(f" Auto-exclude: Skipping /video/ URLs") + if output == Path("doc_dump.md"): # Only use auto output if user didn't specify + output = auto_output + typer.echo(f" Output: {output}") + + # Parse include patterns if provided + include_pattern_list = None + if include_patterns: + include_pattern_list = [p.strip() for p in include_patterns.split(",")] + + # Use auto exclude patterns if available + exclude_pattern_list = auto_exclude_patterns + + # Create content filter function + content_filter_func = None + if content_filter: + # Manual filter takes precedence + def filter_func(content: str) -> bool: + return content_filter in content + + content_filter_func = filter_func + elif auto_filter_func: + # Use auto filter from predefined target + content_filter_func = auto_filter_func + + # Use content processor from predefined target if available + content_processor_func = auto_processor_func + + async def run_crawler() -> None: + async with DocsCrawler( + base_url=actual_url, + include_patterns=include_pattern_list, + exclude_url_patterns=exclude_pattern_list, + content_filter=content_filter_func, + content_processor=content_processor_func, + ) as crawler: + output_path = await crawler.run(output) + typer.echo( + typer.style( + f"✓ Documentation successfully crawled and saved to: {output_path}", + fg=typer.colors.GREEN, + ) + ) + + try: + asyncio.run(run_crawler()) + except Exception as e: + import traceback + + traceback.print_exc() + typer.echo(typer.style(f"✗ Error: {str(e)}", fg=typer.colors.RED), err=True) + raise typer.Exit(code=1) from e + + +@app.command(name="list-targets") +def list_targets() -> None: + """List available predefined targets for ingestion.""" + typer.echo("Git Repository Targets (use with 'from-git'):") + for target in TargetRepo: + typer.echo(f" - {target.name.lower().replace('_', '-')}: {target.value}") + + typer.echo("\nWebsite Targets (use with 'from-web'):") + for target in TargetWebsite: + name = target.name.lower().replace('_', '-') + typer.echo(f" - {name}: {target.value}") + # Show special features for specific targets + if target == TargetWebsite.STARKNET_BLOG_2025: + typer.echo(f" → Skips video URLs (ending with /video/)") + typer.echo(f" → Filters for 2025 blog entries only") + typer.echo(f" → Removes 'Join our newsletter' sections") + typer.echo(f" → Removes 'May also interest you' sections") + + +@app.command(name="list-types") +def list_types() -> None: + """List supported documentation types.""" + typer.echo("Supported documentation types:") + for doc_type in DocumentationType: + typer.echo(f" - {doc_type.value}") + + +@app.command(name="fix-headers") +def fix_headers( + input_file: Path = typer.Argument(help="Path to the markdown file to fix"), + output_file: Optional[Path] = typer.Option( + None, + "--output", + "-o", + help="Output file path. If not specified, overwrites the input file", + ), + keywords: Optional[str] = typer.Option( + None, + "--keywords", + "-k", + help="Comma-separated list of keywords to fix (e.g., 'Examples,Arguments,Returns')", + ), + no_interactive: bool = typer.Option( + False, + "--no-interactive", + "-n", + help="Apply fixes without asking for confirmation", + ), +) -> None: + """Fix markdown headers that should be subsections of their parent headers. + + This utility fixes headers that are at the wrong level, making them proper + subsections of their parent headers. + """ + + # Validate input file + if not input_file.exists(): + typer.echo( + typer.style( + f"✗ Error: Input file '{input_file}' does not exist", fg=typer.colors.RED + ), + err=True, + ) + raise typer.Exit(code=1) + + if input_file.suffix.lower() not in [".md", ".markdown"]: + typer.echo( + typer.style( + f"⚠ Warning: Input file '{input_file}' does not appear to be a markdown file", + fg=typer.colors.YELLOW, + ) + ) + + # Parse keywords if provided + keywords_list = None + if keywords: + keywords_list = [k.strip() for k in keywords.split(",")] + typer.echo(f"Using custom keywords: {keywords_list}") + + # Create header fixer + fixer = HeaderFixer(keywords_to_fix=keywords_list) + + # Process the file + try: + typer.echo(f"Processing: {input_file}") + changes_made = fixer.process_file( + input_path=input_file, output_path=output_file, interactive=not no_interactive + ) + + if not changes_made and output_file and output_file != input_file: + # If no changes but user specified different output, copy the file + import shutil + + shutil.copy2(input_file, output_file) + typer.echo(f"No changes needed. File copied to: {output_file}") + + except Exception as e: + typer.echo(typer.style(f"✗ Error: {str(e)}", fg=typer.colors.RED), err=True) + raise typer.Exit(code=1) from e + + +if __name__ == "__main__": + app() diff --git a/python/src/scripts/summarizer/generated/blog_summary.md b/python/src/scripts/summarizer/generated/blog_summary.md deleted file mode 100644 index bdeb7193..00000000 --- a/python/src/scripts/summarizer/generated/blog_summary.md +++ /dev/null @@ -1,4450 +0,0 @@ -# www.starknet.io — Snapshot (2025-10-09) - ---- - -Sources: - -- https://www.starknet.io/blog/introducing-garden-on-starknet-a-direct-path-for-btc-bridging/ - ---- - -## Bridge BTC to Starknet: Introducing Garden - -Home  /  Blog - -Apr 29, 2025 · 2 min read - -We’re thrilled to announce that Garden – a bridge for BTC-native liquidity – is now live on Starknet. This launch creates a direct, streamlined path for Bitcoin to flow into Starknet, focusing on speed, low fees, and minimal trust assumptions. - -## What Sets Garden Apart - -Garden’s integration with Starknet makes it easy for Bitcoin holders to access Starknet while keeping control of their assets. At the same time, it allows developers and DeFi protocols to tap into BTC liquidity, unlocking new possibilities for apps and flows across the Starknet ecosystem. Sending BTC to Starknet is now straightforward, whether using a crypto wallet like Argent or swapping directly on Garden. The entire process is simplified with a real-time system that finds the best route for your transaction, keeping costs low and execution fast, even for larger trades. On Garden, swap BTC, USDC, WBTC, cbBTC, and more from Bitcoin, Base, Arbitrum, Ethereum, Berachain, and Hyperliquid to Starknet in a single click. - -Bridge BTC to Starknet → - -## More About Starknet - -Starknet is a general-purpose L2 ZK-Rollup that operates above Ethereum and allows users to write and deploy smart contracts and interact with other contracts. Starknet produces bundled transactions offchain via STARK proofs, which are then submitted to Ethereum as a single transaction, allowing dApps to scale while benefiting from Ethereum’s security features massively. Starknet will be the first L2 to settle on both Bitcoin and Ethereum, unifying the two largest blockchains on a single layer. As an L2 on top of Bitcoin, Starknet will become Bitcoin’s execution layer, to trustlessly scale Bitcoin to thousands of transactions per second (TPS). - -Explore Starknet’s vision and roadmap to see how this aligns with broader ecosystem growth. If you’re deep into Bitcoin, building the next wave of DeFi, or just excited about where Ethereum is heading, now’s the time to plug in and bridge BTC to Starknet. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Atomiq brings wBTC to Starknet, enabling Bitcoin DeFi - - BTC-to-wBTC swaps are now live on Starknet using onchain escrows and Bitcoin PoW validation, with no bridges or custodians. - - April 16, 2025 - -- #### Starknet over Bitcoin: Vitalik, Dan Held, and Jeremy Rubin react - - Starknet will become the first Layer 2 to settle on Bitcoin. Learn what Vitalik Buterin and two Bitcoin OGs think about the move. - - March 30, 2025 - -- #### Bitcoin Lightning Network payments with STRK—now live on Starknet via Braavos - - Braavos now enables Bitcoin Lightning Network payments with STRK on Starknet—no BTC, no extra setup, just tap and pay - - March 13, 2025 - -- #### Starknet on Bitcoin and Ethereum: The first L2 to unify both chains - - Starknet will become Bitcoin’s execution layer, massively scaling Bitcoin and opening the door to complex Bitcoin applications. - - March 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/lombard-brings-bitcoin-to-starknet-through-lbtc-integration/ - ---- - -## Bringing Bitcoin to Starknet with Lombard's LBTC - -Home  /  Blog - -May 14, 2025 · 2 min read - -Starknet is proud to announce a strategic partnership with Lombard Protocol, a Bitcoin staking protocol and developer of LBTC. Lombard is bringing LBTC—the leading liquid staked Bitcoin asset—into the Starknet ecosystem, unlocking new earning opportunities and pushing forward a powerful vision: a single, scalable execution layer for both Ethereum and Bitcoin. - -## What is LBTC? - -LBTC is liquid-staked Bitcoin, built on top of Babylon, free to be used across DeFi. Each LBTC token is fully backed 1:1 by real BTC, staked to the Babylon Bitcoin staking protocol. Users obtain LBTC by staking native BTC on the Lombard Protocol, effectively locking their Bitcoin and receiving an equal amount of LBTC in return. This asset can be used for lending, borrowing, trading, and liquidity provisioning across many blockchains, including Ethereum, Base, and Sui. - -## LBTC on Starknet - -Over the coming months, users will be able to stake native BTC for LBTC and bridge LBTC to and from Starknet with ease. Starknet users will gain access to LBTC and Lombard’s DeFi vault through the upcoming integration. This initiative is designed to activate Bitcoin capital within the fast-growing Starknet DeFi ecosystem, offering a secure and seamless experience for both institutional and individual users. - -Institutions will gain a powerful tool to deploy Bitcoin capital across DeFi dApps with greater scalability. Retail users and app developers will benefit from increased liquidity, earn-generating strategies, and new use cases. - -## Lombard and Starknet - -Lombard Protocol’s mission to bring Bitcoin into DeFi aligns perfectly with Starknet’s long-term vision of becoming the execution layer for both Ethereum and Bitcoin. This collaboration represents a key milestone in building a modular, multi-chain DeFi ecosystem, where assets from both chains can flow freely and unlock new possibilities. - -With its focus on decentralization, Starknet is emerging as a natural home for Bitcoin assets in DeFi, offering a reliable foundation for BTC’s thriving in a cross-chain, modular ecosystem. - -**Stay tuned for the integration** - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-bitcoin-scaling/ - ---- - -## Starknet scaling Bitcoin: The first L2 to settle on Bitcoin & Ethereum - -Home  /  Blog - -Mar 11, 2025 · 7 min read - -Bitcoin is more than just a financial asset: It’s a movement rooted in individual sovereignty and the separation of money from the state. Over the past 16 years, it has empowered millions of people around the world to reclaim control over their assets, catalyzing a revolution in how we think about money and trust. And yet, most Bitcoin today sits static in wallets and exchanges, constrained by the limitations of the network’s original design: a lack of scalability and an inability to natively support applications beyond simple buying, selling, and transferring. - -Starknet is embarking on a journey to lift both of those limitations and unleash Bitcoin’s full potential, all while preserving its core principles. Developed in part by the inventors of STARK proofs, Starknet will become the first Layer 2 to settle on both Bitcoin and Ethereum, unifying the world’s largest blockchains on a single layer. The goal is **_to serve 1 billion Bitcoin users_,** introducing improved UX, scale, and liquidity—all without compromising on security or decentralization. - -Efforts across the Starknet ecosystem are already underway to prepare the grounds to achieve this goal. Alongside the continued research and advocacy for OP_CAT, the proposed Bitcoin upgrade that would pave the way for natively bridging Starknet to the network, the following announcements were just unveiled: - -- **Xverse integration**: The leading Bitcoin wallet, Xverse, will integrate with Starknet, enabling the use of Bitcoin assets on Starknet for the first time. -- **BTCFi Season**: The Starknet Foundation is introducing BTCFi Season, a program that will introduce a range of opportunities to put your Bitcoin to work through Starknet. -- **Strategic Bitcoin Reserve**: StarkWare, the company behind the STARK proof that contributes to the development of Starknet, is a Bitcoin-standard company and now has a Strategic Bitcoin Reserve (SBR), holding a growing portion of its treasury as BTC. -- **Lightning Network payments:** Anyone using the Braavos wallet mobile app can scan a QR code and make instant payments using STRK at any vendor that accepts Lightning Network payments. - -Now, let’s dive deeper into the vision for Starknet over Bitcoin. - -## The Starknet vision for Bitcoin - -### The challenge - -Bitcoin set the bar for the core values that make blockchain transformative: decentralization, trustlessness, and censorship-resistance. The vast majority of Bitcoin, however, isn’t being used for anything beyond buying, selling, and long-term investing (HODLing). - -While some investors view Bitcoin as digital gold—a long-term hedge against inflation and economic instability, rather than as an asset to actively trade or leverage—there is a demand for utilizing Bitcoin for purposes beyond that. Think, for example, of using Bitcoin as collateral to buy assets outside the digital domain or to earn the way you do with many other assets. Interviews and research conducted by StarkWare—the company that initially developed the zero-knowledge (ZK) technology that powers Starknet—identified three main barriers to doing so: - -- **Limited Bitcoin functionality:** The Bitcoin network doesn’t natively support complex applications, restricting it primarily to simple transactions and holding (HODLing). -- **Security & centralization risks:** Applications that enable DeFi actions outside of Bitcoin often involve custodial or third-party platforms that introduce risk (e.g. the Celsius, BlockFi, and FTX collapses). -- **Slow, costly transactions:** Bitcoin’s block times and fees can deter everyday transactions or more sophisticated onchain use cases. - -Starknet will make these challenges obsolete. - -### The Starknet solution - -As a Layer 2 on top of Bitcoin, Starknet will become **Bitcoin’s execution layer,** with the goal of trustlessly scaling Bitcoin from 13 transactions per second (TPS) to thousands**.** Because Starknet will enable native expressiveness on Bitcoin at scale for the first time, it will open the floodgates to more complex applications that were previously not supported on Bitcoin. - -With its battle-tested technology, Starknet will bring Bitcoin: - -- **Layer 2 scaling:** Starknet scales blockchain by executing many transactions offchain and bundling them into a single STARK proof that attests to their validity on L1. -- **STARK proofs:** These proofs are quantum-resistant and require no trusted setup, ensuring trustlessness and high security for all Bitcoin-centric activities on Starknet. -- **Instant & cheap transactions:** Starknet transactions finalize in seconds and cost fractions of a cent, addressing Bitcoin’s scalability bottleneck. -- **Expressiveness:** Developers will be able to build a wide variety of DeFi and other complex applications on Bitcoin through Starknet’s smart contract functionality. Applications such as staking, borrowing and lending, leveraged trading, and yield farming will become natively possible on Bitcoin via Starknet. - -With these advantages and more, Starknet is fully equipped to scale Bitcoin with integrity while expanding its utility. - -### Long-term impact - -By scaling Bitcoin and enabling more sophisticated applications on the Bitcoin blockchain in a trustless environment, Starknet will unleash the true potential of the world’s original blockchain. This will result in: - -- **Global reach:** The goal is for Starknet to serve **a billion Bitcoin users**, bringing mainstream financial-grade functionality to the Bitcoin network. -- **Security & decentralization:** Starknet enables Bitcoiners to do more with their Bitcoin on Starknet without compromising on security, as Starknet progresses toward its own decentralized operation. -- **Unified blockchain ecosystem:** With Bitcoin and Ethereum consolidated on Starknet’s execution layer, the broader blockchain community can enjoy faster, cheaper, and more secure onchain interactions. - -### Why Starknet? - -After years of operating on Ethereum, Starknet is the cheapest Layer 2 with Ethereum data availability (DA) and near-instant transaction confirmation, powered by the most advanced ZK tech stack in the blockchain industry. With the following advantages and more, Starknet is fully equipped to bring massive scale to Bitcoin while preserving its core principles: - -- **Proven track record:** The technology behind Starknet has already processed millions of transactions on Ethereum, with cumulative trading of +1.3 trillion USD. -- **Built by the original creators of STARKs:** The STARK proofs used on Starknet were developed by the original inventors of the technology itself. -- **Enhanced user experience:** Native account abstraction means more familiar login methods (fingerprint, face ID), and other features that simplify crypto usage. - -### Breakthrough research on Bitcoin scaling - -The StarkWare team that originally pioneered the technology behind Starknet has invested time and resources into Bitcoin research to promote Bitcoin scaling, bolstered by its OP_CAT research fund. These efforts have already yielded notable achievements. - -Collider-script, for example, introduced a method for enforcing covenants on Bitcoin outputs without requiring any changes to Bitcoin. Covenants are one of the primary components necessary for bringing smart contracts-and therefore expressiveness-to Bitcoin. This was followed by the demonstration of a demo bridge covenant on Bitcoin, which aims to be the foundation of a production-grade bridge from Bitcoin to Starknet. - -In an open-source effort, led by Weikeng Chen and Pinghzou Yuan, StarkWare has already verified the first-ever ZK proof on Bitcoin’s Signet test network using its STARK verifier. - -### Why now? - -While Starknet started by settling on the Ethereum blockchain, its roots in Bitcoin are deep—pre-Ethereum deep. It all started when Professor Eli Ben-Sasson, CEO and Co-Founder of StarkWare, spoke at the Bitcoin Conference in San Jose back in 2013. It was then that he first introduced the idea of using ZK proofs (specifically, the tech later called zk-STARK) to scale Bitcoin. - -Since then, Starknet emerged to bring massive scalability to Ethereum with STARK proofs as its core security technology. Now, as Bitcoin sees record global interest and demand, the time has come for Starknet to step up to its next challenge. - -## How will this be achieved? - -### The Starknet experience on Bitcoin now - -Bitcoin users deserve to be able to utilize their Bitcoin with confidence, and the highest level of security and decentralization. Starknet stakeholders have been and will continue to educate about and advocate for OP_CAT, a proposed Bitcoin upgrade that would, as StarkWare has identified, open the door to natively settling Starknet on Bitcoin. Even before the OP_CAT upgrade, however, efforts will be made to enable using Bitcoin on Starknet with the following kinds of bridges: - -#### Federated model (multisig) - -In the federated model of bridging Starknet to Bitcoin, a group of co-signers collectively safeguards the Bitcoin tokens locked and minted on Starknet through a multisig. The federation is accountable for minting an identical amount of wrapped Bitcoin on Starknet as the amount being bridged. The multisig bridge enables lower fees and elevated UX, but requires that the majority of the signers are honest participants, limiting network liveness. - -#### BitVM - -BitVM is the most secure way to bridge Bitcoin without OP_CAT. Instead of working with a multisig, BitVM requires that only one of the operators is honest. It enables this by enforcing the logic with a dispute-resolution mechanism powered by cryptographic proofs. - -### OP_CAT readiness - -The OP_CAT soft fork, if it passes, will open the door to covenants and native L2 scaling and expressiveness on Bitcoin, empowering the world’s first blockchain to live up to its potential to disrupt traditional financial systems. - -Covenants enable programmable spending rules and, therefore, native smart contracts. Together with STARK proofs, they make it possible to build a fully trustless, native bridge from Bitcoin to Starknet. This native bridge will function without any additional operators or trust assumptions, providing Bitcoin users with the maximal level of security, decentralization, and self-custody. - -A more technical, deeper dive into how Starknet will settle on Bitcoin will be shared in the coming days. - -## Next steps - -In the next few months, several products and partnerships will pave the way for the best possible L2 experience for Bitcoiners on Starknet. These include offerings and incentives that users will be able to enjoy, as well as announcements on major milestones in the research being conducted: - -- **Partnerships:** Starknet stakeholders are forming alliances with key Bitcoin ecosystem players, including wallet providers and researchers. -- **New products & offerings:** Multiple new products and retail offerings will be introduced in the coming months to encourage the adoption of Starknet for Bitcoin. -- **BTCFi Season:** The Starknet Foundation is introducing BTCFi Season, a program designed to open up a range of opportunities to all Bitcoin users. This program will incentivize Bitcoin holders to participate in DeFi on Starknet, allowing users to put their Bitcoin to work in a wide variety of ways. Sign up with your email to be among the first to know when the program goes live. -- **Research & Education:** Ongoing efforts focus on advocating for Bitcoin upgrades like OP_CAT and exploring how STARK proofs can scale Bitcoin’s functionality. StarkWare launched the OP_CAT Research Fund for this purpose. - -## What should you do now? - -Starknet stakeholders are already moving quickly to make Starknet the first Layer 2 to unify Bitcoin and Ethereum without compromising their integrity. What should you do in the meantime? - -Start by setting up a Starknet wallet and check out the Bitcoin DeFi opportunities on BTCFi Season. Browse Starknet’s apps—exactly the kinds of apps that Starknet will make possible on Bitcoin. If you’re a builder who is excited about Starknet as the unifying execution layer for Bitcoin and Ethereum and would like to build the next killer app, check out the Starknet docs to get started. - -Follow Starknet on X to stay updated on all upcoming news. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Introducing Garden on Starknet: A direct path for BTC bridging - - Garden is live on Starknet, offering a direct path for Bitcoin liquidity. Bridge Bitcoin to Starknet with Garden for fast, low-fee DeFi. - - April 29, 2025 - -- #### Atomiq brings wBTC to Starknet, enabling Bitcoin DeFi - - BTC-to-wBTC swaps are now live on Starknet using onchain escrows and Bitcoin PoW validation, with no bridges or custodians. - - April 16, 2025 - -- #### Starknet over Bitcoin: Vitalik, Dan Held, and Jeremy Rubin react - - Starknet will become the first Layer 2 to settle on Bitcoin. Learn what Vitalik Buterin and two Bitcoin OGs think about the move. - - March 30, 2025 - -- #### Bitcoin Lightning Network payments with STRK—now live on Starknet via Braavos - - Braavos now enables Bitcoin Lightning Network payments with STRK on Starknet—no BTC, no extra setup, just tap and pay - - March 13, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/decentralized-starknet-2025/ - ---- - -## Starknet’s Decentralization Roadmap in 2025 - -Home  /  Blog - -Feb 26, 2025 · 5 min read - -Blockchain makes it possible for people to control their assets and transact directly with others on a trustless, secure, and censorship-resistant network. That ideal has the potential to transform entire industries, and it can only be achieved on blockchains that are truly decentralized. Blockchains dominated by a single party or conglomerate don’t _really_ have an edge over traditional, centralized networks. - -With the goal of bringing blockchain’s promise to everyone, Starknet is on the path to becoming the first fully decentralized Layer 2 (L2) that massively scales Ethereum. The recent launch of the first phase of staking on Starknet was a leap toward greater decentralization. This year, efforts to enhance Starknet’s decentralization will ramp up on top of continued performance optimizations. - -## Decentralized Starknet in 2025 - -Ethereum was the first blockchain to enable general-purpose computing. It earned its reputation for staying true to the first principles of blockchain: decentralization and security. As a Layer on top of—and thus an extension of—Ethereum, Starknet must also be decentralized and secure. - -The terms “decentralization” and “security” are often used interchangeably. While it’s true that decentralization enhances security, we distinguish between the two in this post. That’s because, unlike other L2 rollups, Starknet has had its ironclad security technology—STARK proofs—in place from the beginning. There has never been a state update approved on Starknet that wasn’t validated by a proof. That means it’s virtually impossible for an invalid transaction to be processed on Starknet. This post will zero in specifically on Starknet’s decentralization journey, and the ways in which it will progress in 2025. - -Starknet’s road to decentralization runs on three main lanes: - -- **Staking:** Building economic security on Starknet toward the decentralized operation of its Proof-of-Stake (PoS) consensus mechanism - -- **Operation:** The decentralization of Starknet’s operation - -- **Governance:** The independence of the Starknet Security Council - -Let’s dive into Starknet’s progress in each of these lanes, and what’s coming up. - -#### Breaking speed records with 992 peak TPS - -Build Lightning-Fast, Scalable dApps on Starknet - -Explore Starknet - -##### - -### Staking - -Crucial to the decentralized operation of Starknet is the acquisition of economic security on the network, a process that is already under way. At a high level, here’s what this means: - -Starknet uses Proof-of-Stake (PoS) as its mechanism for preventing Sybil attacks, in which a single entity or group of entities creates multiple validators to gain disproportionate influence over the network. PoS prevents these attacks by requiring validators to stake tokens. This ensures influence over the network is proportional to the economic cost of acquiring and risking tokens, rather than the number of validators created. - -On Layer 1 PoS protocols, staking starts from genesis, and the consensus layer’s security generally improves with its economic value. For rollups, such as Starknet, the story is different. - -Rollups inherit the security of their settlement layer and accrue economic value even if they don’t decentralize their operation. This dynamic provides an advantage to rollups that _are_ on the path to decentralizing their protocol, such as Starknet. That’s because it opens the door to accumulating high amounts and a wide distribution of stake before the decentralization of the protocol. This sets decentralized, public Starknet up in a way that prevents the disproportionate influence of a select few on the network, fostering its stability and a wide distribution of validators. - -As such, Starknet is first gathering _economic security_ through staking, and only afterward allowing for decentralized operation of the protocol. - -To this end, Starknet staking began as an _application_, decoupled from consensus—Phase 1 of Starknet staking (Staking v1) went live on November 26, 2024, and has been accumulating economic security ever since. To date, more than 170 million in STRK is being staked by 63,000 delegators and 106 validators. - -Stake your STRK → - -Staking v2 will enter mainnet in Q2 of 2025, coupling staking rewards to stakers attesting blocks. Staking v3 will enter mainnet in Q4 of 2025, coupling staking rewards to block validation. Finally, Staking v4 will make validators fully responsible for maintaining and securing the network by producing, attesting, and proving blocks. - -Each stage of staking contributes to building economic security and opens the door to the decentralized operation of the Starknet protocol. - -### Operation - -In addition to economic security, the decentralization of Starknet’s operation requires a fully functional open-source stack with end-to-end functionality. Enter the SN Stack, which has just recently been made available and enables anyone to use the parts that power Starknet. - -The present architecture of public Starknet relies on the open-source Stone prover and a closed-source sequencer, which are complemented by the open-source Madara and Katana sequencers. Throughout 2025, public Starknet will migrate to a newer stack, founded on the next-gen Apollo sequencer and the Stwo prover, both of which will be open-source. Stwo will make proving on Starknet much more efficient. - -The next step toward the decentralized operation of Starknet will be the decentralization of the consensus layer. This means validators will vote on each Starknet block, and only a sufficient quorum of such votes will finalize a new block. Decentralized consensus is planned to go live on mainnet at the end of 2025. Here is the game plan in broad strokes: - -1. Starknet v0.14.0: Launch of the distributed sequencer architecture comprised of an internal network of 3f+1 nodes running consensus and taking turns building and proposing blocks -2. Production release of the next-gen-sequencer for anyone to run -3. Deployment on Testnet(s) -4. Deployment on Mainnet - -We have omitted subtler milestones pertaining to client diversity, which is crucial for a robust network. We’ll just say there are three _additional_ full nodes that are presently integrating consensus and block proposal functionality: Juno, Pathfinder, and Madara (which needs only consensus). - -### Governance - -Given a fixed protocol, there are “meta” matters pertaining to protocol changes. Governance of such matters is a difficult problem without any canonical solutions. For L1 networks, “the protocol” is practically defined by the majority of nodes in the network: If most nodes collaboratively modify their clients, the network remains the same while its protocol changes. Hence, L1 networks can have “informal” governance—nothing is set in stone. - -Rollups, on the other hand, have core contracts on their settlement layers. Even if all L2 clients were modified, the core contract itself can only change through action on the settlement layer. Hence, rollup governance requires explicit permissioning for modifying L1 core contracts. - -The Starknet Security Council is a governance mechanism that decentralizes control over core contracts (both on L1 and L2) pertaining to state updates, staking, and STRK minting (which is managed by smart contracts, unlike Ethereum, where rewards are implemented at the client level). - -Moreover, the Security Council’s capacity to perform L1 state updates allows it to bypass consensus in case of censorship of L1/L2 messages. Thus, the Security Council facilitates censorship resistance in addition to its governance functions. - -A Security Council is a first step toward the decentralized governance of a decentralized Starknet. However, the challenge is broader than formal control core contracts. The governance question has social and technical aspects that require much thought. Improving the decentralization of the mechanism is a core goal of decentralized Starknet. - -## Other features - -While big decentralization moves are set to be made on Starknet this year, other features that aren’t decentralization-related, such as additional fee reductions and UX/DevX improvements, will also be launched. - -**v0.13.4:** This version upgrade introduces: - -- **Stateful compression:** Will reduce fees - -- **L2 gas price:** Introduces fixed price, denominated in fri, for a single unit of L2 gas until fee market in v0.14.4; it decouples L2 computation fees from the L1 gas market - -- **Try/catch for function call failures** - -- **Cairo-native (Sierra → LLVM):** Will boost performance, and potentially TPS - -**v0.14.0:** In addition to the distributed sequencer and potentially Stwo integration, this version will introduce: - -- **2-second blocks, mempool, & fee market:** Better UX, DevX - -For a deeper dive into upcoming features, read the Starknet v0.13.4 pre-release notes, with more to come on v0.14.0. - -## Conclusion - -The journey toward decentralized, scalable blockchain is a monumental challenge, but it must be achieved if blockchain is to achieve its full potential. Starknet stands at the forefront of this mission, proving that scalability and decentralization can coexist without compromise. By advancing staking, open-sourcing its stack, and progressing toward decentralized governance, Starknet is not only shaping its own future but also setting a benchmark for what L2s can achieve. - -Stay tuned for updates about Starknet’s decentralization journey on X. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet launches phase 1 of its staking initiative on mainnet - - Get an overview of Starknet's phase 1 staking protocol, a major step in Starknet's journey toward full decentralization. - - November 26, 2024 - -- #### What is Staking in Blockchain? Understanding Crypto Staking’s Risks and Rewards - - Learn how staking plays a vital role in network integrity, decentralization, and security. - - September 29, 2024 - -- #### Snapshot X: Onchain governance by Starknet - - Snapshot X combines the security and verifiability of onchain voting with the frictionless ease and modularity for which Snapshot is known. - - September 9, 2024 - -- #### First Starknet community vote on mainnet - - The first community vote on Starknet mainnet proposes a minting curve to enable staking rewards on the network. - - September 9, 2024 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-v0135-blob-compression/ - ---- - -## Starknet v0.13.5: Lower Fees With Blob Compression - -Home  /  Blog - -Mar 25, 2025 · 4 min read - -By the time you’re reading this, Starknet will already be on **v0.13.5**—but all the big improvements came in **v0.13.4**. The v0.13.5 upgrade rolled out immediately after v0.13.4, bringing minor adjustments to help the ecosystem gear up for the next big upgrade. So, to keep things simple (and avoid confusion), let’s just call it **v0.13.5**, cool? - -The **v0.13.5** Starknet upgrade is now live on mainnet, significantly improving transaction costs and developer experience (DevX). This upgrade ensures that Starknet remains **cost-efficient, even as demand for Ethereum blobs increases**—by optimizing blob usage through state diff compression. Additionally, this version lays the groundwork for the **future fee market** by introducing a new concept: **L2 gas**. - -Let’s dive into what’s new and why it matters. - -## Shelter from the blobstorm - -With demand for Ethereum blobs steadily rising and costs becoming a growing concern, Starknet is staying ahead of the curve. The v0.13.5 upgrade continues Starknet’s commitment to low fees by significantly improving how data is submitted to Ethereum. By optimizing blob usage, it reduces the impact of rising blob costs and makes transactions more cost-efficient. - -The foundation for this was laid in **v0.13.3**, which introduced **stateless compression**. This allowed blobs to be submitted to L1 in a compressed form, reducing the overall size of data Starknet sends to Ethereum. Now, **v0.13.5 builds on this with stateful compression**, an upgrade that optimizes how storage keys are encoded over time, minimizing redundancy and making state updates far more efficient. - -### How does stateful compression work? - -Rather than treating every transaction’s data independently, **stateful compression** tracks and optimizes how storage keys appear over multiple state updates. This means that instead of repeatedly writing the full storage key in the state diff, Starknet can now reference it using an “alias” (a small integer)—**packing more diffs into each Ethereum blob** **and further driving down L1 costs**. - -With this upgrade, Starknet transactions remain as cost-efficient as possible, even in the face of rising Ethereum data costs, reinforcing Starknet’s position as a cost-efficient scaling solution built to last. - -## Future-proofing Starknet: Introducing L2 gas - -Optimizing blob compression is just one piece of making Starknet more cost-efficient for the long run. The next step? Redesigning how fees are structured altogether. - -This upgrade **lays the foundation for what comes next**. Enter **Layer 2** gas-a new resource model introduced in v0.13.5 that will serve as the backbone of **Starknet’s future fee market, planned for v0.14.0**. This shift will make fees more predictable, scalable, and sustainable, reducing volatility over time and setting the stage for a more efficient fee market. - -### What does each type of gas pay for? - -Until now, Starknet transaction fees were closely tied to Ethereum’s gas mechanics. That’s slowly changing. With L2 gas, **each transaction now specifies three separate gas resources and bids**, each covering different aspects of execution and data availability: - -- **L2 gas** covers all **L2-native resources**. -- **L1 gas** covers **L2→L1 messages** sent by the transaction. -- **L1 data gas (aka blob gas)** covers the cost incurred by the sequencer for **submitting state diffs as blobs on L1**. - -**By separating L2 execution costs from L1 gas**, Starknet is preparing the ground for a more predictable and scalable fee structure. This is a key step toward long-term cost stability and performance improvements. Over time, this will allow Starknet to fine-tune its own fee model-ensuring efficient pricing without being directly impacted by Ethereum’s fluctuating gas costs. - -## Don’t panic: Error handling for a better DevX - -Beyond fee reductions, v0.13.5 also gives developers a major improvement in contract execution: **error handling**. Smart contracts can now catch errors instead of aborting execution immediately. - -Allowing contracts to catch and handle execution failures translates to a more robust developer experience. With this change, developers gain greater control over execution flows and can now write more resilient applications that respond to unexpected conditions instead of just reverting. - -This is part of a broader shift towards making Starknet easier and more intuitive for developers. Alongside error handling, v0.13.5 introduces a new Wallet-Dapp API, streamlining how wallets and applications interact. It removes rigid dependencies on specific versions of Starknet.js, ensuring the ecosystem can rely on an agreed standard, while also leading to easier integrations between dApps and wallets. - -**Thinking about building on Starknet?** Now’s the time. With lower fees, better DevX, and a growing ecosystem, there’s never been a better moment to build on Starknet. - -## Laying the groundwork for what’s next - -While v0.13.5 brings improvements today, it’s also setting the stage for even bigger things ahead. One of the most intriguing additions is **Cairo-native execution**, a performance boost that allows contracts to run as native machine code instead of being interpreted by the Cairo VM. This optimization is undergoing extensive testing and isn’t being activated on mainnet just yet, but it signals the direction Starknet is heading: toward higher throughput, faster execution, and a network that can scale effortlessly. - -And that’s just the beginning. **v0.14.0 is coming**, bringing 2-second blocks, fee market, and even more efficiency improvements. Every upgrade moves Starknet closer to its goal: becoming a blockchain network that’s scalable, cost-efficient, developer-friendly, and built to last. - -**Want to see what’s coming next?** Explore upcoming features, release timelines, and how the network keeps evolving in the Starknet roadmap. - -## Final Thoughts - -With cheaper transactions, an improved execution model, and a clear path toward scalability, Starknet v0.13.5 is setting the stage for the future of blockchain applications. Whether you’re a developer, a builder, or an everyday user, this upgrade ensures that Starknet remains the best place to build and transact affordably. - -**For a deeper dive** into the technical intricacies of this upgrade, check out the Starknet v0.13.4 Pre-release Notes. And yeah, we’re calling it v0.13.5 here-get with the game. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet on Bitcoin and Ethereum: The first L2 to unify both chains - - Starknet will become Bitcoin’s execution layer, massively scaling Bitcoin and opening the door to complex Bitcoin applications. - - March 11, 2025 - -- #### Starknet’s road to decentralization in 2025 - - Discover Starknet’s roadmap to decentralization in 2025: protocol governance, sequencer evolution, and ecosystem empowerment. - - February 26, 2025 - -- #### The Starknet ‘Bolt’ upgrade: 2-second txs are here - - Read about Starknet v0.13.2 upgrade that boosts dApps performance on Ethereum with faster transactions, parallel execution, and block packing. - - August 28, 2024 - -- #### Cairo gets high marks from Starknet devs - - The developer experience on Starknet has changed significantly this past year, and here's what developers had to say about it. - - August 14, 2024 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-decentralization-a-roadmap-in-broad-strokes/ - ---- - -## Starknet’s Decentralization Roadmap in 2025 - -Home  /  Blog - -Feb 26, 2025 · 5 min read - -Blockchain makes it possible for people to control their assets and transact directly with others on a trustless, secure, and censorship-resistant network. That ideal has the potential to transform entire industries, and it can only be achieved on blockchains that are truly decentralized. Blockchains dominated by a single party or conglomerate don’t _really_ have an edge over traditional, centralized networks. - -With the goal of bringing blockchain’s promise to everyone, Starknet is on the path to becoming the first fully decentralized Layer 2 (L2) that massively scales Ethereum. The recent launch of the first phase of staking on Starknet was a leap toward greater decentralization. This year, efforts to enhance Starknet’s decentralization will ramp up on top of continued performance optimizations. - -## Decentralized Starknet in 2025 - -Ethereum was the first blockchain to enable general-purpose computing. It earned its reputation for staying true to the first principles of blockchain: decentralization and security. As a Layer on top of—and thus an extension of—Ethereum, Starknet must also be decentralized and secure. - -The terms “decentralization” and “security” are often used interchangeably. While it’s true that decentralization enhances security, we distinguish between the two in this post. That’s because, unlike other L2 rollups, Starknet has had its ironclad security technology—STARK proofs—in place from the beginning. There has never been a state update approved on Starknet that wasn’t validated by a proof. That means it’s virtually impossible for an invalid transaction to be processed on Starknet. This post will zero in specifically on Starknet’s decentralization journey, and the ways in which it will progress in 2025. - -Starknet’s road to decentralization runs on three main lanes: - -- **Staking:** Building economic security on Starknet toward the decentralized operation of its Proof-of-Stake (PoS) consensus mechanism - -- **Operation:** The decentralization of Starknet’s operation - -- **Governance:** The independence of the Starknet Security Council - -Let’s dive into Starknet’s progress in each of these lanes, and what’s coming up. - -#### Breaking speed records with 992 peak TPS - -Build Lightning-Fast, Scalable dApps on Starknet - -Explore Starknet - -##### - -### Staking - -Crucial to the decentralized operation of Starknet is the acquisition of economic security on the network, a process that is already under way. At a high level, here’s what this means: - -Starknet uses Proof-of-Stake (PoS) as its mechanism for preventing Sybil attacks, in which a single entity or group of entities creates multiple validators to gain disproportionate influence over the network. PoS prevents these attacks by requiring validators to stake tokens. This ensures influence over the network is proportional to the economic cost of acquiring and risking tokens, rather than the number of validators created. - -On Layer 1 PoS protocols, staking starts from genesis, and the consensus layer’s security generally improves with its economic value. For rollups, such as Starknet, the story is different. - -Rollups inherit the security of their settlement layer and accrue economic value even if they don’t decentralize their operation. This dynamic provides an advantage to rollups that _are_ on the path to decentralizing their protocol, such as Starknet. That’s because it opens the door to accumulating high amounts and a wide distribution of stake before the decentralization of the protocol. This sets decentralized, public Starknet up in a way that prevents the disproportionate influence of a select few on the network, fostering its stability and a wide distribution of validators. - -As such, Starknet is first gathering _economic security_ through staking, and only afterward allowing for decentralized operation of the protocol. - -To this end, Starknet staking began as an _application_, decoupled from consensus—Phase 1 of Starknet staking (Staking v1) went live on November 26, 2024, and has been accumulating economic security ever since. To date, more than 170 million in STRK is being staked by 63,000 delegators and 106 validators. - -Stake your STRK → - -Staking v2 will enter mainnet in Q2 of 2025, coupling staking rewards to stakers attesting blocks. Staking v3 will enter mainnet in Q4 of 2025, coupling staking rewards to block validation. Finally, Staking v4 will make validators fully responsible for maintaining and securing the network by producing, attesting, and proving blocks. - -Each stage of staking contributes to building economic security and opens the door to the decentralized operation of the Starknet protocol. - -### Operation - -In addition to economic security, the decentralization of Starknet’s operation requires a fully functional open-source stack with end-to-end functionality. Enter the SN Stack, which has just recently been made available and enables anyone to use the parts that power Starknet. - -The present architecture of public Starknet relies on the open-source Stone prover and a closed-source sequencer, which are complemented by the open-source Madara and Katana sequencers. Throughout 2025, public Starknet will migrate to a newer stack, founded on the next-gen Apollo sequencer and the Stwo prover, both of which will be open-source. Stwo will make proving on Starknet much more efficient. - -The next step toward the decentralized operation of Starknet will be the decentralization of the consensus layer. This means validators will vote on each Starknet block, and only a sufficient quorum of such votes will finalize a new block. Decentralized consensus is planned to go live on mainnet at the end of 2025. Here is the game plan in broad strokes: - -1. Starknet v0.14.0: Launch of the distributed sequencer architecture comprised of an internal network of 3f+1 nodes running consensus and taking turns building and proposing blocks -2. Production release of the next-gen-sequencer for anyone to run -3. Deployment on Testnet(s) -4. Deployment on Mainnet - -We have omitted subtler milestones pertaining to client diversity, which is crucial for a robust network. We’ll just say there are three _additional_ full nodes that are presently integrating consensus and block proposal functionality: Juno, Pathfinder, and Madara (which needs only consensus). - -### Governance - -Given a fixed protocol, there are “meta” matters pertaining to protocol changes. Governance of such matters is a difficult problem without any canonical solutions. For L1 networks, “the protocol” is practically defined by the majority of nodes in the network: If most nodes collaboratively modify their clients, the network remains the same while its protocol changes. Hence, L1 networks can have “informal” governance—nothing is set in stone. - -Rollups, on the other hand, have core contracts on their settlement layers. Even if all L2 clients were modified, the core contract itself can only change through action on the settlement layer. Hence, rollup governance requires explicit permissioning for modifying L1 core contracts. - -The Starknet Security Council is a governance mechanism that decentralizes control over core contracts (both on L1 and L2) pertaining to state updates, staking, and STRK minting (which is managed by smart contracts, unlike Ethereum, where rewards are implemented at the client level). - -Moreover, the Security Council’s capacity to perform L1 state updates allows it to bypass consensus in case of censorship of L1/L2 messages. Thus, the Security Council facilitates censorship resistance in addition to its governance functions. - -A Security Council is a first step toward the decentralized governance of a decentralized Starknet. However, the challenge is broader than formal control core contracts. The governance question has social and technical aspects that require much thought. Improving the decentralization of the mechanism is a core goal of decentralized Starknet. - -## Other features - -While big decentralization moves are set to be made on Starknet this year, other features that aren’t decentralization-related, such as additional fee reductions and UX/DevX improvements, will also be launched. - -**v0.13.4:** This version upgrade introduces: - -- **Stateful compression:** Will reduce fees - -- **L2 gas price:** Introduces fixed price, denominated in fri, for a single unit of L2 gas until fee market in v0.14.4; it decouples L2 computation fees from the L1 gas market - -- **Try/catch for function call failures** - -- **Cairo-native (Sierra → LLVM):** Will boost performance, and potentially TPS - -**v0.14.0:** In addition to the distributed sequencer and potentially Stwo integration, this version will introduce: - -- **2-second blocks, mempool, & fee market:** Better UX, DevX - -For a deeper dive into upcoming features, read the Starknet v0.13.4 pre-release notes, with more to come on v0.14.0. - -## Conclusion - -The journey toward decentralized, scalable blockchain is a monumental challenge, but it must be achieved if blockchain is to achieve its full potential. Starknet stands at the forefront of this mission, proving that scalability and decentralization can coexist without compromise. By advancing staking, open-sourcing its stack, and progressing toward decentralized governance, Starknet is not only shaping its own future but also setting a benchmark for what L2s can achieve. - -Stay tuned for updates about Starknet’s decentralization journey on X. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet launches phase 1 of its staking initiative on mainnet - - Get an overview of Starknet's phase 1 staking protocol, a major step in Starknet's journey toward full decentralization. - - November 26, 2024 - -- #### What is Staking in Blockchain? Understanding Crypto Staking’s Risks and Rewards - - Learn how staking plays a vital role in network integrity, decentralization, and security. - - September 29, 2024 - -- #### Snapshot X: Onchain governance by Starknet - - Snapshot X combines the security and verifiability of onchain voting with the frictionless ease and modularity for which Snapshot is known. - - September 9, 2024 - -- #### First Starknet community vote on mainnet - - The first community vote on Starknet mainnet proposes a minting curve to enable staking rewards on the network. - - September 9, 2024 - ---- - -Sources: - -- https://www.starknet.io/blog/cairo-improvements/ - ---- - -## DevEx improvements for Cairo developers are here - -Home  /  Blog - -Mar 23, 2025 · < 1 min read - -_This post was originally published on the Cairo website._ - -Cairo has heard your feedback and is actively working on addressing it! Here are some of the most requested features for Scarb and Starknet Foundry that have just been released for Cairo developers. - -## One-line installer - -Setting up Scarb and Starknet Foundry can be a bit tedious: It requires setting up asdf, adding the plugins for Scarb and Starknet Foundry, and installing the latest version. - -Now, all of this is replaced by a single one-liner: - -``` -curl --proto '=https' --tlsv1.2 -sSf https://sh.starkup.sh | sh -``` - -The following will: - -- Install asdf if you still don’t have it installed -- Download the latest version of the tools -- Set the global variables - -And that’s it! - -You should now have all the essential tools you need to start building, compiling, and testing Cairo contracts for Starknet. - -This tool tries to capture as many edge cases as possible, but no software is perfect. If you have any issues or requests, please open a new issue on the GitHub repo. - -## No more Cargo for Cairo - -Recent Scarb and Starknet Foundry users might have noticed that when updating to a new Starknet Foundry version, the complications begin with compiling… Rust? - -This wasn’t intuitive, and many users didn’t quite understand what was going on and why. For the full explanation, read the rest of this post on the Cairo website: - -Read full post → - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Cairo gets high marks from Starknet devs - - The developer experience on Starknet has changed significantly this past year, and here's what developers had to say about it. - - August 14, 2024 - -- #### ​​The What’s What of the Cairo World - - Delve into Starknet's foundational elements: Cairo VM, CASM, Cairo Zero, Cairo, and Sierra. Discover their pivotal role in Layer 2 scaling, enhancing Ethereum efficiency,… - - September 11, 2023 - -- #### The case for Appchains powered by a decentralized Starknet stack - - The Starknet Stack is in the midst of a remarkable growth spurt. We expect it to dominate the Appchain space due to its performance,… - - July 19, 2023 - -- #### Starknet Quantum Leap: Major Throughput Improvements are Here! - - Starknet Alpha V0.12.0 focuses on enhancing performance and user experience. The new version introduces a Rust-based implementation of the Sequencer, improving throughput by 10X… - - July 5, 2023 - ---- - -Sources: - -- https://www.starknet.io/blog/noir-on-starknet/ - ---- - -## Verify Noir ZK proofs on Starknet with Garaga SDK - -Home  /  Blog - -Mar 20, 2025 · 2 min read - -Zero-knowledge (ZK) proofs are key to building privacy-preserving applications. Starknet makes verifying these proofs both cheap and seamless, enabling the scalable development of ZK-enabled apps. The goal, therefore, is to constantly expand the umbrella of developers who enjoy access to efficient proof verification on Starknet. - -To that end, StarkWare and the Starknet Foundation now collaborate with Aztec, a leading privacy network, to introduce a new wave of developers to Starknet. Anyone using Noir—the popular ZK language—can now verify Noir proofs on Starknet without needing to write any Cairo code. This is made possible with the Garaga SDK, developed by Feltroid Prime and supported by StarkWare. So whether you are a Noir developer or a Cairo developer, you can now verify efficiently on Starknet. - -## Starknet: A hub for ZK-enabled apps - -Starknet’s native smart-contract language, Cairo, is purpose-built to harness the unparalleled power of STARK proofs. But the Starknet ecosystem continues to ensure developers using other programming languages can also benefit from Starknet’s capabilities, turning Starknet into a hub for ZK-enabled apps. - -Using Garaga, Noir developers can compile their programs to automatically generate a Cairo verifier, deploy it on Starknet, and verify proofs without writing any Cairo code—all while enjoying lower fees and enhanced performance. This makes it possible for Noir developers to build scalable applications ranging from ZK machine learning (ZKML) to Layer 2 (L2) and Layer 3 (L3) appchains, to other ZK-enabled dApps. - -## How Garaga SDK works - -Garaga makes deploying Noir verifiers on Starknet effortless. Here’s how it works: - -- **Noir-program compilation:** When you compile your Noir code using Garaga, it automatically produces a Noir prover, and a Noir verifier contract written in Cairo. -- **Easy deployment**: The generated verifier is ready for immediate deployment on Starknet. This means you don’t need to learn or write Cairo—Garaga handles the heavy lifting. -- **Cost & performance benefits**: By moving proof verification to Starknet, developers can leverage significantly lower transaction fees and faster processing than traditional onchain verification methods. - -## Get started - -Whether you’re an experienced Noir developer or just beginning your journey into ZK proofs, Garaga offers a cost-effective, high-performance platform to bring your ideas to life. - -For more detailed steps, see the Garaga documentation on generating a Starknet smart contract from your Noir program, or start building with Cairo today. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/develop-dapp-starknet-js/ - ---- - -## Develop End-to-End Starknet dApps with Starknet.js - -Home  /  Blog - -May 22, 2025 · 6 min read - -Starknet is a powerful Layer 2 scaling solution for Ethereum that enables developers to deploy and interact with **Cairo-based smart contracts**. But how do we build an end-to-end dApp, from **contract deployment** to **frontend interaction**? - -We relied on **Starkli** (Starknet CLI) to deploy contracts, which is a banger. However, with **Starknet.js**, we can **interact with contracts seamlessly from our frontend** without switching tools. In this guide, we will: - -- **Deploy a contract to Starknet** -- **Read from and write a contract using Starknet.js** -- **Integrate with a Next.js frontend** -- **Connect a Starknet crypto wallet (ArgentX or Braavos)** -- **Perform transactions (increase/decrease a counter)** - -By the end, you’ll have **a fully functional Starknet dApp** running with **Starknet.js**. - -The source code of this demo can be accessed here. - -# Getting Started - -## Prerequisites - -To follow this guide, ensure you have: - -- **Node.js** (v18+) -- **Yarn or npm** -- **A Starknet wallet (ArgentX or Braavos)** -- **Basic knowledge of TypeScript & Next.js** -- **Cairo (for smart contracts)** -- **Scarb (Starknet package manager)** - -There is a single command installation too! You can follow this 1 minute video guide. - -## **Step 1: Setting Up a New Project** - -Simply create a new folder where you want your project to be: - -``` -mkdir counter -scarb init -``` - -You should have the option to choose between the Cairo test and Starknet Foundry; I went ahead with the recommended one for this tutorial. - -This should create a src folder with a lib.cairo file, which will be our contract file in Cairo. This tutorial is not focused on learning cairo but for developers who want to learn Starknet.js, hence using a simple counter contract to interact with smart contract is used. - -This is new lib.cairo file in Cairo which has 3 major functions: - -- read the counter value -- increase the counter value with a custom argument provided through frontend -- decrease the counter value - -``` -// Cairo 2.9.2 - -#[starknet::interface] -trait ITestSession { - fn increase_counter(ref self: TContractState, value: u128); - fn decrease_counter(ref self: TContractState, value: u128); - fn get_counter(self: @TContractState) -> u128; -} - -#[starknet::contract] -mod test_session { - use starknet::storage::StoragePointerWriteAccess; - use starknet::storage::StoragePointerReadAccess; - - #[storage] - struct Storage { - count: u128, - } - - #[abi(embed_v0)] - impl TestSession of super::ITestSession { - fn increase_counter(ref self: ContractState, value: u128) { - self.count.write(self.count.read() + value); - } - - fn decrease_counter(ref self: ContractState, value: u128) { - let current = self.count.read(); - if current >= value { - self.count.write(current - value); - } else { - self.count.write(0); // Prevents underflow - } - } - - fn get_counter(self: @ContractState) -> u128 { - self.count.read() - } - } -} -``` - -Once the contract is there, we should build it to get the casm and sierra files. This can be done using these commands. Make sure to be inside the contracts folder. This step might take a while. - -``` -cd contracts -scarb build -``` - -After compiling, your **ABI** (Application Binary Interface) and contract artifacts will be inside target/dev/ including sierra and casm files. - -## **Step 2: Connecting to a Starknet Wallet** - -### Installing a wallet - -Download **ArgentX** or **Braavos**: - -• ArgentX Chrome Extension– standard account - -• Braavos Wallet - -Once installed, **create an account** and **fund it with Sepolia ETH**. - -## **Step 3: Deploying the Contract** - -We will use **Starknet.js** to deploy the contract. - -**For this tutorial, we’d need:** - -1. The contract’s ABI -2. The contract’s Address -3. An Argent or Braavos wallet -4. React.js [front-end framework] -5. Starknetjs [dependency]Make a new file called deploy.ts in the root directory. Since, our contract is already there as we’re using public RPC URL, we’d just be deploying a new instance of it. If you’re using your own new contract, follow these steps to deploy it. - -This is your deploy.ts file which is simply used to deploy your contract. Here we’re only deploying a new instance of it. You’d need a wallet account with the address, private key, and classHash of the contract. To save the ABI, I’ve logged it here and saved it in a separate JSON file inside public folder as you’d need to access it later. - -After your contract is deployed, save its address and check it on Starkscan/voyager. - -``` -import { - Contract, - Account, - json, - shortString, - RpcProvider, - hash, -} from "starknet"; -import fs from "fs"; - -async function main() { - const provider = new RpcProvider({ - nodeUrl: "https://starknet-sepolia.public.blastapi.io", - }); - - // Check that communication with provider is OK - const ci = await provider.getChainId(); - console.log("chain Id =", ci); - - // Initialize existing Argent X testnet accountn - const accountAddress = - "0x..."; - const privateKey = - "0x...."; - const account0 = new Account(provider, accountAddress, privateKey); - console.log("existing_ACCOUNT_ADDRESS =", accountAddress); - console.log("existing account connected.\n"); - - // Since we already have the classhash, we will be skipping this part - const testClassHash = - "0x396823b2b056397dc8f3da80d20ae8f4b0630d33b089b36ba3c3c9a7a51c7d0"; - - const deployResponse = await account0.deployContract({ classHash: testClassHash }); - await provider.waitForTransaction(deployResponse.transaction_hash); - - // Read ABI of Test contract - const { abi: testAbi } = await provider.getClassByHash(testClassHash); - if (testAbi === undefined) { - throw new Error("no abi."); - } - - // ✅ Log Full ABI - console.log("Full ABI:", JSON.stringify(testAbi, null, 2)); - - // Connect the new contract instance: - const myTestContract = new Contract(testAbi, deployResponse.contract_address, provider); - console.log("✅ Test Contract connected at =", myTestContract.address); -} - -// contract address: 0x75410d36a0690670137c3d15c01fcfa2ce094a4d0791dc769ef18c1c423a7f8 - -main() - .then(() => process.exit(0)) - .catch((error) => { - console.error(error); - process.exit(1); - }); -``` - -Use this command to run your deploy file. - -``` -npx tsx deploy.ts -``` - -I’ve attached my ABI.json file here for reference: - -``` -[ - { - "type": "impl", - "name": "TestSession", - "interface_name": "counter_starknetjs::ITestSession" - }, - { - "type": "interface", - "name": "counter_starknetjs::ITestSession", - "items": [ - { - "type": "function", - "name": "increase_counter", - "inputs": [ - { - "name": "value", - "type": "core::integer::u128" - } - ], - "outputs": [], - "state_mutability": "external" - }, - { - "type": "function", - "name": "decrease_counter", - "inputs": [ - { - "name": "value", - "type": "core::integer::u128" - } - ], - "outputs": [], - "state_mutability": "external" - }, - { - "type": "function", - "name": "get_counter", - "inputs": [], - "outputs": [ - { - "type": "core::integer::u128" - } - ], - "state_mutability": "view" - } - ] - }, - { - "type": "event", - "name": "counter_starknetjs::test_session::Event", - "kind": "enum", - "variants": [] - } - ] -``` - -## Step 4: Connecting contracts to frontend - -Create a new folder and initialize it with the next.js (App router), and install starknet-react, which uses starknet.js under the hood to interact with frontend. - -``` -mkdir web -npx create-next-app@latest starknet-counter -cd starknet-counter -npm install starknet @starknet-react/core @starknet-react/chains -``` - -Move your ABI.json file to the public folder to access it more easily. - -Create a new component called Providers.tsx to configure chains, providers, connectors, wallets, and accounts. This will be a client-side component. - -``` -"use client"; -import React from "react"; - -import { sepolia } from "@starknet-react/chains"; -import { - StarknetConfig, - argent, - braavos, - useInjectedConnectors, - voyager, - jsonRpcProvider -} from "@starknet-react/core"; - -export function Providers({ children }: { children: React.ReactNode }) { - const { connectors } = useInjectedConnectors({ - // Show these connectors if the user has no connector installed. - recommended: [ - argent(), - braavos(), - ], - // Hide recommended connectors if the user has any connector installed. - includeRecommended: "onlyIfNoConnectors", - // Randomize the order of the connectors. - order: "random" - }); - - return ( - ({nodeUrl: process.env.NEXT_PUBLIC_RPC_URL})})} - connectors={connectors} - explorer={voyager} - > - {children} - - ); -} -``` - -Then go to your layout.tsx file and wrap it in the Providers component. Don’t forget to import it. This is how it should look like: - -``` -import type { Metadata } from "next"; -import { Geist, Geist_Mono } from "next/font/google"; -import "./globals.css"; -import { Providers } from "./components/Providers"; - -const geistSans = Geist({ - variable: "--font-geist-sans", - subsets: ["latin"], -}); - -const geistMono = Geist_Mono({ - variable: "--font-geist-mono", - subsets: ["latin"], -}); - -export const metadata: Metadata = { - title: "Counter Starknetjs", - description: "Counter demo by starknet js", -}; - -export default function RootLayout({ - children, -}: Readonly<{ - children: React.ReactNode; -}>) { - return ( - - - - {children} - - - - - ); -} -``` - -We’d need another component to check wallet connection; this will also be a client-side component that will let the users connect or disconnect their Braavos or Argent wallet while also showing their address. This is how my WalletBar.tsx file looks like: - -``` -"use client"; -import { useConnect, useDisconnect, useAccount } from "@starknet-react/core"; - -const WalletBar: React.FC = () => { - const { connect, connectors } = useConnect(); - const { disconnect } = useDisconnect(); - const { address } = useAccount(); - - return ( -
- {!address ? ( -
- {connectors.map((connector) => ( - - ))} -
- ) : ( -
-
- 🔗 Connected: {address.slice(0, 6)}...{address.slice(-4)} -
- -
- )} -
- ); -}; - -export default WalletBar; -``` - -## Step 4: Reading data from blockchain - -We’d modify our page.tsx file to read the data from blockchain and connect our wallet as well. This will also be loaded on the client side so, add “use client” on the top. - -We will be using pre-defined react hooks for this. - -``` -export default function Home() { - // ✅ Read the latest block - const { data: blockNumberData, isLoading: blockNumberIsLoading, isError: blockNumberIsError } = useBlockNumber({ blockIdentifier: "latest" }); - - // ✅ Read your balance - const { address: userAddress } = useAccount(); - const { isLoading: balanceIsLoading, isError: balanceIsError, error: balanceError, data: balanceData } = useBalance({ address: userAddress, watch: true }); -} -``` - -## Step 5: Interacting with smart contracts - -For this- we will call functions defined in the contract to increase or decrease the counter. - -``` -export default function Home() { - // ✅ Read from a contract - const contractAddress = "0x75410d36a0690670137c3d15c01fcfa2ce094a4d0791dc769ef18c1c423a7f8"; - const { data: readData, isError: readIsError, isLoading: readIsLoading, error: readError } = useReadContract({ - functionName: "get_counter", - args: [], - abi: ABI as Abi, - address: contractAddress, - watch: true, - refetchInterval: 1000, - }); - - // ✅ Increase & Decrease Counter - const [amount, setAmount] = useState(0); - const handleAmountChange = (event: React.ChangeEvent) => { - const value = event.target.value; - setAmount(value === "" ? "" : Number(value)); - }; -``` - -That’s it! - -You can design the UI as preferred. Here’s how a simple UI can look with all the basic functionality required: - -## **Conclusion** - -In this guide, we: - -- **Wrote & deployed a Starknet contract using Starknet.js** -- **Connected a Starknet wallet** -- **Interacted with the contract using Starknet.js** -- **Designed a Next.js frontend** - -This tutorial provides a **solid foundation** for building **full-stack dApps on Starknet**. The **full source code is available on GitHub**. - -## Resources: - -1. Source code on GitHub- https://github.com/reetbatra/starknetjs-counter -2. Official Starknet.js docs- https://starknetjs.com/docs/guides/intro -3. Starknet-react docs- https://www.starknet-react.com/docs/getting-started -4. Counter contract example- https://starknet-by-example.voyager.online/getting-started/basics/counter - -Stay tuned for more such tutorials along the way. See you in the trenches! - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/paymaster-the-secret-to-making-dapps-feel-like-web2/ - ---- - -## Paymaster: The Secret to Making dApps Feel Like Web2 | Starknet - -Home  /  Blog - -May 21, 2025 · 4 min read - -Imagine a world where gas fees no longer hinder smooth and frictionless transactions. With **Paymaster**, we’ve brought this vision to life by allowing users to pay their gas fees using **various tokens**, eliminating the need to hold ETH or STRK just to cover transaction costs. - -Whether you hold **stablecoins, major tokens, or other assets**, you can now transact freely, focusing entirely on using the dApp to its full potential without the hassle of gas management. - -In this blog, we’ll explore **Paymaster’s core functionalities**, its benefits, and how you can integrate it into your **Starknet dApp** for a seamless user experience. - -## What is Paymaster? - -**Paymaster** is an innovative solution that enables **gasless transactions** and flexible gas payments. Instead of requiring users to hold ETH or STRK for transaction fees, Paymaster allows dApps to either **sponsor gas fees** or let users pay using **any supported token**. - -### How Does Paymaster Work? - -1. **Sponsor Gas Fees**: The dApp covers the user’s gas costs, creating a frictionless onboarding experience. -2. **Flexible Token Payments**: Users can pay gas fees with any token they hold, not just ETH or STRK. -3. **Meta-Transactions**: Transactions can be executed on behalf of users, making interactions smoother. - -### Benefits of Paymaster: - -- **Frictionless UX** – No need for users to manage gas tokens. -- **Onboarding Simplification** – New users can interact with dApps without holding ETH. -- **Gas Payments in Any Token** – Users can pay gas fees with stablecoins or any supported token. -- **Improved dApp Adoption** – Lower barriers encourage more interaction. - -> **Use Case Example:**Imagine a DeFi platform where users can swap tokens without worrying about ETH for gas fees. Paymaster makes this possible! -> -> or… -> -> POAPs! You can sponsor user’s gas fees to mint NFTs for free! Now, if that is not onboarding your grandma onchain, idk what is - ---- - -## AVNU’s Paymaster on Starknet - -### **Architecture Overview** - -- **User chooses a gas token**: Instead of ETH, users select USDC, USDT, or another supported asset. -- **Signature Approval**: Users sign a transaction without needing ETH. -- **API Calls**: The dApp makes calls to fetch gas prices, generate typed data, and execute transactions. -- **Transaction Execution**: The Paymaster service handles the rest, ensuring smooth blockchain execution. - -Before diving into **AVNU’s Gasless SDK**, let’s first understand why we need **Paymaster** and whether there are alternative solutions. - -### **The Problem with Traditional Gas Fees** - -On Ethereum and Starknet, users must hold **ETH (or STRK)** to pay for transaction fees. This creates several friction points: - -- New users must **acquire ETH/STRK** before using a dApp. -- Managing multiple tokens for **gas and transactions** adds complexity. -- **Due to gas fee requirements, DeFi, gaming, and consumer applications** struggle with adoption - -- ### **Are There Alternative Solutions?** - - There are a few other solutions available: - - - **Meta-transactions** (Users sign messages, relayers execute the transaction, covering gas fees.) - - **Third-party sponsorship services** (Protocols or projects cover gas fees for new users.) - - **Layer 2 scaling** **solutions** reduce fees but still require ETH/STRK. - -Among these, **AVNU’s Paymaster** offers **a flexible** and **developer-friendly** approach, allowing both sponsorship and token-based gas payments. - -## **Gasless vs Gas-Free: Understanding the Difference** - -### **Gas-Free Transactions** - -Gas-Free means **no fees for the user or dApp**—transactions are executed without any cost. This typically requires a sponsor (like a project or protocol) covering all gas fees. - -### **Gasless Transactions** - -Gasless means the **user doesn’t need ETH** for gas but still pays fees using another token. This eliminates the need to manage ETH, making transactions smoother while keeping a decentralized cost structure. - -## **Do You Need an API Key for Paymaster?** - -### **When is an API Key Required?** - -An **API key is required** in the following cases: - -- **Sponsoring transactions** – If a dApp wants to cover the gas fees on behalf of users, it must authenticate via an API key. -- **Using advanced Paymaster features**, such as rewards-based gas sponsorship. -- **Building and executing typed data via the API** – Required for sponsored transactions. - -### **When is an API Key Not Required?** - -An **API key is NOT required** when: - -- The user is **paying gas fees themselves** using supported tokens (e.g., USDC, USDT, etc.). -- Checking **account compatibility** with the gasless service. -- Fetching **gas token prices** for display in the UI. - ---- - -## Implementing AVNU’s Paymaster in Your Starknet dApp - -## **Setting Up a Basic Starknet Project** - -Before jumping into AVNU’s Gasless SDK, let’s first set up a basic Starknet project. This will help you understand how Paymaster integrates into a real-world dApp. - -### **Step 1: Creating a New Starknet Project** - -Start by setting up a new JavaScript/TypeScript project for Starknet development. - -``` -mkdir starknet-gasless-dapp && cd starknet-gasless-dapp -npm init -y # or yarn init -y -``` - -### **Step 2: Installing Required Dependencies** - -``` -yarn add starknet dotenv @avnu/gasless-sdk axios -``` - -### - -### **Step 3: Setting Up a .env File for API Keys** - -Create a `.env` file to securely store your API keys: - -``` -touch .env -``` - -Inside `.env`, add: - -``` -PAYMASTER_API_KEY=your-api-key-here -``` - -### **Step 4: Setting Up a Basic Starknet Account & Contract Call** - -``` -import { Provider, Account, Contract } from "starknet"; -import dotenv from "dotenv"; -dotenv.config(); - -const provider = new Provider({ rpc: "https://starknet.api.avnu.fi" }); -const account = new Account(provider, "YOUR_ACCOUNT_ADDRESS", "YOUR_PRIVATE_KEY"); - -async function callContract() { - const contract = new Contract("CONTRACT_ADDRESS", ABI, account); - const result = await contract.call("functionName", [param1, param2]); - console.log("Result:", result); -} - -callContract(); -``` - -At this point, we have set up a basic Starknet project that interacts with a contract. However, **this setup still requires ETH/STRK for gas fees**—this is where AVNU’s Gasless SDK comes in. - -## **Using the Gasless SDK Without an API Key** - -If the user is paying gas fees in an alternative token, we can proceed without an API key. - -### **Checking Gasless Compatibility** - -``` -import { fetchAccountCompatibility } from '@avnu/gasless-sdk'; - -async function checkCompatibility(accountAddress) { - const compatibility = await fetchAccountCompatibility(accountAddress); - console.log("Gasless Compatible:", compatibility.isCompatible); -} -``` - -### **Fetching Gas Token Prices** - -``` -import { fetchGasTokenPrices } from '@avnu/gasless-sdk'; - -async function getGasPrices() { - const prices = await fetchGasTokenPrices(); - console.log("Gas Token Prices:", prices); -} -``` - -### **Executing a Gasless Transaction (User Pays with a Supported Token)** - -``` -import { executeCalls } from '@avnu/gasless-sdk'; - -async function executeGasless(account, calls) { - const response = await executeCalls(account, calls, { - gasTokenAddress: "USDC", // User pays gas in USDC - maxGasTokenAmount: BigInt(1000000000), - }); - console.log("Transaction Hash:", response.transactionHash); -} -``` - -## **Using the Gasless SDK With an API Key (Sponsored Transactions)** - -If the dApp wants to sponsor gas fees, we need to use an API key. Contact AVNU to get your own API key. - -### **Fetching Gasless Service Status** - -``` -import axios from 'axios'; -import dotenv from 'dotenv'; -dotenv.config(); - -async function checkGaslessStatus() { - const response = await axios.get('https://starknet.api.avnu.fi/paymaster/v1/status'); - console.log("Gasless Service Status:", response.data); -} -``` - -### **Building Typed Data for Sponsored Transactions** - -``` -async function buildTypedData(userAddress, calls) { - const response = await axios.post('https://starknet.api.avnu.fi/paymaster/v1/build-typed-data', { - userAddress, - gasTokenAddress: null, // Sponsored gas - maxGasTokenAmount: null, // Sponsored gas - calls, - }, { - headers: { 'api-key': process.env.PAYMASTER_API_KEY }, - }); - console.log("Typed Data:", response.data); -} -``` - -### **Executing Sponsored Transactions** - -``` -async function executeSponsoredTransaction(userAddress, typedData, signature) { - const response = await axios.post('https://starknet.api.avnu.fi/paymaster/v1/execute', { - userAddress, - typedData, - signature, - }, { - headers: { 'api-key': process.env.PAYMASTER_API_KEY }, - }); - console.log("Sponsored Transaction Hash:", response.data.transactionHash); -} -``` - ---- - -## Additional Resources - -- AVNU Docs -- Argent Wallet & Session Keys - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/on-chain-gaming-starknet-dojo/ - ---- - -## The Rise of On-Chain Gaming: Building on Starknet with Dojo Engine | Starknet - -Home  /  Blog - -May 8, 2025 · 6 min read - -Gaming has evolved significantly, from traditional board games to digital experiences, and now, to on-chain games — a completely new paradigm enabled by blockchain technology. As blockchain-based ecosystems flourish, particularly with the scaling solutions offered by layer 2 technologies, developers have begun exploring new business models, financial incentives, and decentralized ownership structures that were previously impossible. - -In this article, we’ll explore the need for on-chain games, their advantages, and how Dojo Engine helps developers build provable, decentralized, and autonomous games faster than ever before. - -## **History of Games: From Board Games to On-Chain Games** - -Games have been integral to human history, from ancient board games like Chess and Go to modern digital experiences like World of Warcraft and Fortnite. However, the underlying structure of games has remained largely centralized — players interact with a game world owned and controlled by a central entity (developers, publishers, or platforms). - -### - -### **The Transition to On-Chain Games** - -On-chain games introduce a revolutionary concept: games where both state and logic exist entirely on a blockchain. This means that: - -- The game’s rules and mechanics are enforced by smart contracts. -- Players have true ownership over in-game assets. -- The game state is public, auditable, and tamper-proof. -- Games can be composable, allowing external developers to build on top of existing game worlds. - -## - -## **Why Do We Need On-Chain Games?** - -While traditional games rely on centralized servers and game economies controlled by publishers, on-chain games offer a radically different approach: - -### **1. Financialization as Part of the Game** - -Unlike traditional games where financialization is often limited to NFTs, on-chain games integrate economic incentives and value transfer at their core. Players can earn, trade, and stake assets in ways that were previously impossible. - -### **2. Trustless Escrow and Arbitration** - -In traditional games, disputes over in-game assets or transactions rely on centralized authorities. On-chain games use the blockchain as an escrow and arbitrator, ensuring fairness and transparency. - -### **3. New, More Efficient Business Models** - -On-chain gaming allows for atomic payouts, decentralized revenue sharing, and permissionless modding. Developers can monetize gameplay through programmable economies rather than relying on ads or in-game purchases. - -### **4. Composability and Modding** - -The best games in history, such as DOTA and Counter-Strike, started as mods of existing games. On-chain games take this further by offering shared state and open APIs, allowing developers to create new game mechanics, spin-off games, and community-driven extensions. - -**Examples:** - -- **DOTA** (originally a Warcraft 3 mod, now a billion-dollar franchise) -- **Counter-Strike** (originally a Half-Life mod, now a leading FPS title) - ---- - -## **New User-Generated Content (UGC) Business Models** - -On-chain games enable headless games, atomic payouts, and games as protocols, ushering in a new era of community-driven game development. - -### **Examples:** - -- **Loot Survivor Clients** (players generate content in a shared game world) -- **DF Client Plugins** (modular expansions built on top of existing games) - ---- - -## **The Strength of On-Chain Games: Security & High Stakes** - -One of the biggest advantages of on-chain gaming is immutability and trustlessness. - -- **Blockchains exist for escrow**—this is their primary function. -- **On-chain games are impossible to cheat** because game logic is enforced at the smart contract level. -- **High-stakes competitive games** (with financial rewards) become possible without fear of exploitation. - -### **Example: Strategy Game with Buy-Ins** - -A highly competitive real-time strategy (RTS) game where players stake assets before a match. Since all transactions and logic are on-chain, cheating is impossible, and winnings are automatically distributed based on game outcomes. - ---- - -## **Types of On-Chain Games** - -### **1. Short Experiences (Rogue-Likes, Daily Challenges)** - -- Low cost, easy to pick up and play -- Baked-in token loops for rewards -- Game Examples: RYO, Loot Survivor, Paved - -### **2. Session-Based Games (With Stakes, RTS, Civilization-Like Games)** - -- Multiplayer & asynchronous mechanics -- Session-based with buy-ins and rewards -- Game Examples: Eternum, Sky Strife, Dark Forest, ZConquer - -### **3. Autonomous Worlds (Self-Evolving, Persistent Game Worlds)** - -- Decentralized and self-governing -- No single entity owns the game -- No fully autonomous world exists yet, but early prototypes are emerging - -## **What is Dojo?** - -Dojo is an open-source, community-driven provable game engine designed to accelerate on-chain game development. Before Dojo, developers had to build their own indexers, contract architectures, and game clients from scratch. - -With Dojo, developers can go from zero to a fully functional game in just a week. - -### **Why Dojo?** - -- Standardizes the development experience (DevX) for on-chain games -- Simplifies on-chain state management via models -- Minimizes boilerplate code -- Provides powerful developer tooling - ---- - -## **How Does Dojo Work?** - -Dojo extends the Cairo compiler, injects macros, and creates a standardized ORM-like state management system. All states are stored in a World contract, and Dojo contracts mutate this state. - -### **Architecture Overview** - -#### **World Contract** - -- Provides the interface for on-chain worlds -- Designed for composability and extensibility -- Registers models that extend storage -- Deploys contracts that extend logic -- Manages access control for data modifications - ---- - -## **What You Need for This Tutorial** - -To follow along, ensure you have: - -- Dojo installed (`dojoup`) -- Sozo, Katana, Torii, and Origami installed -- A basic understanding of Cairo and smart contract development - -### **Dojo Toolchain Overview** - -- **Sozo**: Command-line tool for managing Dojo projects -- **Torii**: Automatic indexer for your models (SQL/Postgres support) -- **Katana**: Local devnet for testing game logic -- **Origami**: Game development library with common patterns -- **BYO Client**: Official clients in Dojo.js, Unity, C, and more - ---- - -## **Building the Game: Red vs. Blue Team** - -### **Game Overview** - -We are developing **Red vs. Blue Team**, a **map control game** where players join either the **Red** or **Blue** team. Players can **paint tiles** on the game map and aim to **maintain control** of the most territory. However, each player is limited to **one action every 60 seconds**, making strategic tile placement critical. - -### **Game Components** - -To implement this game, we need: - -#### **1. Player Registration** - -- Players will be identified using their **wallet address**. -- Upon registration, a player selects a **team (Red or Blue)**. - -#### **2. Tile System** - -- The game board consists of **tiles**, each defined by **x and y keys**. -- Each tile has a **color** (either Red or Blue) to reflect the controlling team. - -### **Game Functions** - -#### **1. Register Player** - -- A new player joins the game by registering with their **wallet address**. -- The player selects a **team (Red or Blue)**. - -#### **2. Paint Tile** - -- A player selects a **tile (x, y)** to paint in their team’s color. -- A cooldown prevents players from painting **more than once every 60 seconds**. -- The team with the most painted tiles maintains control. - ---- - -# **Let’s jump into code!** - -Contracts and client folders are self-explanatory. However, the key is understanding how we need to run each of them and how they are interlinked. - -Please take a look at the source code here. I initialized the project using the Dojo starter kit. - -The client (React+Vite) application can be run using - -``` -npm install -npm run dev -``` - -Then start the Katana local node with the following command: - -``` -katana --disable-fee --allowed-origins "*" -``` - -In another terminal window, navigate again to the contracts directory and build the contracts using Sozo, and apply the migrations to deploy the contracts: - -``` -sozo build -sozo migrate apply -``` - -Start the Torii server, replacing 0x6457e5a40e8d0faf6996d8d0213d6ba2f44760606e110e03e3d239c5f769e87 with the actual world address if different: - -``` -torii --world 0x6457e5a40e8d0faf6996d8d0213d6ba2f44760606e110e03e3d239c5f769e87 --allowed-origins "*" -``` - -## **Models** - -Models define data structures annotated with `#[dojo::model]` for integration into Dojo. - -### **Tile Model (tile.cairo)** - -``` -#[derive(Copy, Drop, Serde)] -#[dojo::model] -struct Tile { - #[key] - x: u16, - #[key] - y: u16, - color: felt252 -} -``` - -- `#[key] x, y`: Primary keys for grid location. -- `color: felt252`: Stores tile color. - -Each tile represents a grid coordinate where players can paint. - -### **Player Model (player.cairo)** - -``` -const TIME_BETWEEN_ACTIONS: u64 = 120; - -#[derive(Copy, Drop, Serde)] -#[dojo::model] -struct Player { - #[key] - address: starknet::ContractAddress, - player: u32, - last_action: u64 -} - -#[generate_trait] -impl PlayerImpl of PlayerTrait { - fn check_can_place(self: Player) { - if starknet::get_block_timestamp() - self.last_action < TIME_BETWEEN_ACTIONS { - panic!("Not enough time has passed"); - } - } -} -``` - -- `TIME_BETWEEN_ACTIONS`: 120-second cooldown to prevent spam. -- `#[key] address`: Primary key for player identity. -- `check_can_place()`: Enforces action cooldown. - -This structure ensures fair play by restricting frequent updates. - -## **Contract Systems** - -Contracts define the logic that enables players to take actions like spawning and painting tiles. - -### **Actions Contract (actions.cairo)** - -``` -// define the interface -#[dojo::interface] -trait IActions { - fn spawn(); - fn paint(x: u16, y: u16, color: felt252); -} - -#[dojo::contract] -mod actions { - use super::{IActions}; - use starknet::{ContractAddress, get_caller_address, get_block_timestamp}; - use boot_camp_paint::models::{tile::{Tile}, player::{Player}}; - - #[abi(embed_v0)] - impl ActionsImpl of IActions { - fn spawn(world: IWorldDispatcher) { - let address = get_caller_address(); - let player = world.uuid(); - let existing_player = get!(world, (player), Player); - assert(existing_player.last_action == 0, "ACTIONS: player already exists"); - let last_action = get_block_timestamp(); - set!(world, Player { address, player, last_action }); - } - - fn paint(world: IWorldDispatcher, x: u16, y: u16, color: felt252) { - let address = get_caller_address(); - let player = get!(world, (address), Player); - assert(player.address == address, "ACTIONS: not player"); - set!(world, Tile { x, y, color }); - } - } -} -``` - -- **IActions Interface:** Defines the available actions: `spawn()` and `paint(x, y, color)`. -- **spawn() Function:** - - Retrieves the caller’s address. - - Generates a unique player ID. - - Ensures the player doesn’t already exist. - - Records the player in the world state. -- **paint() Function:** - - Retrieves the caller’s address. - - Verifies the caller is an existing player. - - Updates the tile color at the specified `(x, y)` coordinates. - -This system ensures that only registered players can modify tiles and prevents duplicate player creation. - -After running these contracts and building them, you should be able to spin up a local katana devnet. - -## **World Write** - -Once you run the contracts on Katana, you should get a console log of the contract address. Save it for later. - -## **Indexing** - -Then you should be able to start a torii server in a new terminal using this command. - -`torii --world 0x6457e5a40e8d0faf6996d8d0213d6ba2f44760606e110e03e3d239c5f769e87 --allowed-origins "*"` - -Based on this, you should see a graphQL link on the terminal that you can access which will automatically generate schema for you. - -Now, the only portion pending is frontend! Take a look at my older tutorial for the same. - -Wola! This is all you need to get started with dojo-engine. - -## Resources - -1. https://book.dojoengine.org/tutorial/dojo-starter -2. https://www.youtube.com/watch?v=xKYqFMibIB0 -3. https://www.youtube.com/watch?v=sj0lJjufby4 - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/cartridge-controller-lets-talk-about-smooth-ux-for-onchain-games/ - ---- - -## Cartridge Controller: Smoothest UX for onchain games - -Home  /  Blog - -May 5, 2025 · 3 min read - -The gaming industry is undergoing a massive transformation with the rise of Web3, bringing true ownership, decentralized economies, and seamless player experiences. However, one of the biggest roadblocks to mass adoption is the complexity of blockchain authentication and wallet management. - -Enter **Cartridge Controller**-a groundbreaking solution designed to make Web3 gaming as seamless as traditional gaming, eliminating the need for complex wallet interactions, gas fees, and private key management. - -In this blog, we’ll explore how Cartridge Controller is revolutionizing Web3 gaming. It enables developers to create frictionless player experiences with account abstraction, session keys, and smart authentication. - -Before we talk any further, try Art-Peace, an onchain game on Starknet, and don’t forget to log in via Cartridge to check for yourself how smooth the UX is! - -Did you notice how the crypto wallet never prompts you to sign every transaction repeatedly? And did I mention that the gas fees are also covered? It can’t get any better; it seems like a normal game, right? With no pop-ups? - -## **The Problem: Why Web3 Gaming Needs Better Authentication** - -Web3 games introduce features like play-to-earn mechanics, NFT-based assets, and decentralized ownership. However, these benefits often come at a cost: complex user onboarding and frustrating blockchain interaction. - -### **The Current Challenges in Web3 Gaming** - -- **Wallet Management** – Players must set up wallets like MetaMask or Argent to access a game. -- **Gas Fees & Transaction Signing** – Every in-game action (buying items, minting NFTs) requires a blockchain transaction, which means **manual approval and gas fees**. -- **Seed Phrases & Security Risks** – Traditional wallets require users to secure seed phrases, which are difficult for mainstream gamers to manage. -- **Interrupted Gameplay** – Constant signing and wallet pop-ups disrupt the immersive experience of gaming. - -This is where Cartridge Controller comes in. It simplifies Web3 authentication and transactions, making Web3 games feel as smooth as traditional games. - -## **Introducing Cartridge Controller: Web3 Gaming, Simplified** - -Cartridge Controller is a smart authentication system designed to remove the friction of blockchain interactions in Web3 gaming. - -### **How Does Cartridge Controller Work?** - -Instead of forcing players to sign every transaction manually, Cartridge Controller leverages account abstraction and session keys to enable gasless, passwordless, and seamless authentication. - -### **Key Features of** **Cartridge Controller\*\***:\*\* - -- **Walletless Authentication** – Players can sign in using familiar methods (Google, Discord, etc.) instead of managing wallets. -- **Session Keys** – Allows automatic signing of transactions for pre-approved actions, reducing pop-ups. -- **Gasless Transactions** – Removes players needing to hold ETH for gas fees. -- **Account Recovery** – No need to remember seed phrases; accounts can be linked to traditional authentication methods. -- **Security & Customization** – Developers can set up granular permissions for transaction execution. - -With Cartridge Controller, Web3 games can offer a frictionless experience, keeping players engaged without blockchain complexity. - ---- - -## - -## **How to Integrate Cartridge Controller in Your Web3 Game** - -Enough bragging now; let’s dive into setting up the Cartridge Controller in a Web3 game using React. - -#### **1. Install the Cartridge SDK** - -Start by installing the required dependencies: - -``` -yarn add @cartridge/controller starknet react -``` - -#### **2. Initialize the Cartridge Controller** - -Create a `controller.js` file and initialize the Cartridge Controller. - -``` -import { Controller } from '@cartridge/controller'; - -const controller = new Controller({ - app: 'your-game-id', - network: 'starknet-testnet', // or 'starknet-mainnet' -}); - -export default controller; -``` - -#### **3. Connect a Player’s Account** - -In your React component, add a login button that connects a player’s account. - -``` -import React, { useState } from 'react'; -import controller from './controller'; - -const Login = () => { - const [player, setPlayer] = useState(null); - - const connectPlayer = async () => { - const account = await controller.connect(); - setPlayer(account); - }; - - return ( -
- - {player &&

Welcome, {player.address}!

} -
- ); -}; - -export default Login; -``` - -#### **4. Enable Session Keys for Seamless Transactions** - -With session keys, players can automatically sign transactions without manual confirmations. - -``` -const enableSessionKey = async () => { - await controller.authorize({ - actions: ['moveCharacter', 'claimReward'], // Pre-approved actions - duration: 3600, // 1 hour session - }); -}; -``` - -#### **5. Execute an In-Game Transaction Without Pop-Ups** - -``` -const purchaseItem = async () => { - await controller.execute({ - contract: '0xYourGameContract', - method: 'buyItem', - args: [1], // Buy item with ID 1 - }); -}; -``` - -## **Real-World Use Cases: How Web3 Games Can Use Cartridge Controller** - -### **1. NFT-Based Games** - -- Players can mint, trade, and equip NFTs without needing manual transaction approvals. -- Session keys allow automatic weapon/skin upgrades without signing transactions. - -### **2. Play-to-Earn (P2E) Games** - -- Earnings can be claimed without gas fees interrupting the experience. -- Players can stake and withdraw rewards seamlessly. - -### **3. On-Chain Strategy & Card Games** - -- Moves in turn-based strategy games can be auto-signed, keeping gameplay uninterrupted. -- Deck management, trades, and upgrades happen in real-time. - ---- - -## **Resources and further reading:** - -Start by integrating the Cartridge Controller into your Web3 game today! - -- Cartridge Controller Docs -- Getting Started with Cartridge Controller -- React Example Implementation - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/session-keys-on-starknet-unlocking-gasless-secure-transactions/ - ---- - -## How Session Keys on Starknet Revolutionize dApp UX with Gasless Transactions - -Home  /  Blog - -Apr 29, 2025 · 3 min read - -## **Introduction** - -As blockchain adoption grows, user experience remains one of the biggest hurdles. Interacting with decentralized applications (dApps) often requires signing multiple transactions, leading to frustrating delays and gas costs. - -Wouldn’t it be great if users could interact with dApps **seamlessly**, without signing every single transaction? - -This is where **Session Keys** come in. They offer a game-changing way to execute multiple transactions securely without requiring constant user approval. In this guide, we’ll explore the concept of Session Keys on Starknet, understand their benefits, and build a hands-on demo. - -## **What Are Session Keys?** - -A **Session Key** is a temporary key that grants limited transaction execution permissions to a dApp **without requiring user signatures for each action**. Instead of prompting for wallet confirmations on every interaction, session keys enable smooth and uninterrupted dApp usage for a specified period or under defined constraints. - -How Do Session Keys Work? - -1. **User Signs Once**: The user grants permission for a specific session key with predefined rules (e.g., limited to certain functions, time duration, or spending caps). -2. **dApp Executes Transactions**: The dApp uses this session key to sign transactions on behalf of the user within the given constraints. -3. **Session Expires**: After the session key expires (or reaches its limits), it can no longer sign transactions, ensuring security. - -### - -### Why are session keys useful? - -✅ **Gasless Transactions** – Users don’t need to pay for gas on every interaction. - -✅ **Seamless UX** – No need to sign each transaction manually. - -✅ **Fine-Grained Permissions** – Limited scope ensures security. - -✅ **Enhanced Gaming & DeFi** – Enables better automation and fluidity in games and trading platforms. - -> **Use Case Example:**Imagine a blockchain game where you need to approve every move or action. With session keys, the game can execute moves automatically within the approved parameters, improving the user experience! - -## **Session Keys on Starknet** - -Starknet leverages **Account Abstraction (AA)** to enhance smart contract wallets, making session keys possible. Starknet’s session keys operate through **smart contract-based authentication**, allowing fine-tuned access control. - -Key Features: - -- **Smart Contract-Based Access Control**: Permissions are embedded in the wallet’s contract. -- **Granular Constraints**: Developers can define specific function calls, time limits, and spending caps. -- **Enhanced Security**: Session keys have a controlled lifespan, preventing abuse. - -The **Argent Wallet** is a popular implementation of session keys on Starknet, offering developers an API to integrate session-based transactions seamlessly. - -## **Building a Session Key Demo on Starknet** - -Now, let’s build a demo that allows users to interact with a smart contract using session keys, similar to this demo - -**Step 1: Setting Up Your Starknet Environment** - -Ensure you have the following installed: - -``` -curl --proto '=https' --tlsv1.2 -sSf https://sh.starkup.sh | sh -``` - -### **Step 2: Deploying a Smart Contract with Session Key Support** - -We’ll write a simple **Counter Contract** where a session key can increment a counter without needing multiple signatures. - -**Counter Contract (Cairo)** - -``` -#[starknet::interface] -trait ITestSession { - fn increase_counter(ref self: TContractState, value: u128); - fn decrease_counter(ref self: TContractState, value: u128); - fn get_counter(self: @TContractState) -> u128; -} - -#[starknet::contract] -mod test_session { - use starknet::storage::StoragePointerWriteAccess; - use starknet::storage::StoragePointerReadAccess; - - #[storage] - struct Storage { - count: u128, - session_keys: Map, // Store session keys - } - - #[abi(embed_v0)] - impl TestSession of super::ITestSession { - fn increase_counter(ref self: ContractState, value: u128) { - assert!(self.session_keys.contains(&get_caller()), "Unauthorized session key"); - self.count.write(self.count.read() + value); - } - - fn decrease_counter(ref self: ContractState, value: u128) { - assert!(self.session_keys.contains(&get_caller()), "Unauthorized session key"); - let current = self.count.read(); - if current >= value { - self.count.write(current - value); - } else { - self.count.write(0); - } - } - - fn get_counter(self: @ContractState) -> u128 { - self.count.read() - } - - fn add_session_key(ref self: ContractState, key: felt252) { - assert!(is_admin(), "Only admin can add session keys"); - self.session_keys.insert(key, true); - } - - fn remove_session_key(ref self: ContractState, key: felt252) { - assert!(is_admin(), "Only admin can remove session keys"); - self.session_keys.remove(key); - } - } -} -``` - -### **Step 3: Generating and Using a Session Key** - -**Generating a Session Key** - -``` -import { starknet } from "starknet"; - -async function createSessionKey(wallet) { - const sessionKey = starknet.generatePrivateKey(); - const sessionPublicKey = starknet.getPublicKey(sessionKey); - - await wallet.addSessionKey(sessionPublicKey); - - console.log("Session Key Created: ", sessionPublicKey); - return sessionKey; -} -``` - -**Using the Session Key** - -``` -async function useSessionKey(sessionKey, contractAddress) { - const provider = new starknet.Provider(); - const contract = new starknet.Contract(contractAddress, provider); - - await contract.increase_counter(10, { from: sessionKey }); - console.log("Counter incremented using session key!"); -} -``` - -**Session Keys on Starknet**, allows users to interact with a smart contract without manually signing every transaction. By introducing **Session Keys**, we improved UX while maintaining security. - -### **What We Achieved:** - -✅ Implemented a **Session Key-enabled Counter Contract** in Cairo 2.9.2. - -✅ Allowed **temporary access** to session keys with controlled permissions. - -✅ Ensured **security** by restricting actions session keys can perform. - -✅ Demonstrated how **session keys** can enhance gasless transactions and smooth dApp interaction. - -## **Final Thoughts and Resources on Session Keys** - -Session keys provide a robust way to improve blockchain usability by reducing friction in user interactions. With **Account Abstraction (AA) and Session Keys**, developers can build **decentralized applications that feel as smooth as Web2 apps** while maintaining blockchain security and decentralization. - -🚀 **Want to try it out?** - -Deploy your session-key-enabled dApp and share your experience! - -Here is the link to the GitHub repository to follow along: https://github.com/reetbatra/session-keys-demo - -Argent’s guide on session keys: https://docs.argent.xyz/aa-use-cases/session-keys - -More on understanding session keys on starknet: https://starkware.co/blog/session-keys-unlocking-better-ux/#session-keys - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-foundation-announces-support-program-for-payment-applications/ - ---- - -## Starknet Foundation Launches Support Program for Payment Apps - -Home  /  Blog - -Apr 4, 2025 · < 1 min read - -A vibrant Web3 ecosystem isn’t a byproduct of mere speculation. It’s built on real usage. That’s why Starknet Foundation is supporting initiatives and campaigns launched by Starknet projects designed to accelerate this future. - -Let’s take a closer look at how Starknet Foundation is supporting payments applications with this program. - -Apply for a grant now → - -## How is Starknet Foundation supporting payment applications? - -Under this new grants program the Starknet Foundation will provide monthly STRK grants to eligible builders to help them with their acquisition and to bring their application or new application features to their end users. - -## What a successful payments ecosystem looks like - -Success isn’t doing things the same way they have always been done in crypto. It’s seeing people use Starknet applications in every day settings with the best underlying user experience. - -With this initiative, Starknet Foundation envisions both wallets and fintech apps integrating Starknet payments. We see real economic activity driving on-chain transaction volume instead of only speculative trades. The Starknet Foundation also foresees more strategic partnerships across the payment stack, from stablecoin issuers to payment processors and DeFi rails. - -The ultimate goal is for more people to use crypto the way it was always meant to be used: to power economic growth and develop emerging markets. - -## Get involved - -If you’re a wallet, card provider, or payment protocol ready to build the future of crypto payments, Starknet Foundation wants to hear from you! - -Crypto’s next era won’t be powered by hype but by habits. - -Apply for a grant now → - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/going-beyond-limits-bitcoin-ethereum-and-a-new-foundation-for-the-digital-world/ - ---- - -## Going beyond limits: Bitcoin, Ethereum, and Starknet - -Home  /  Blog - -Mar 11, 2025 · 3 min read - -**_By James Strudwick, Executive Director, Starknet Foundation._** - -## A system in need of reinvention - -At Starknet Foundation, our vision is a world where power is shared, creativity is rewarded, and opportunity is accessible to all. As the Starknet L2 moves towards becoming the first protocol to settle on both Bitcoin and Ethereum, I thought it was important to take a moment to talk about this vision, how it has brought us here, and how we see Bitcoin helping us realize it. - -The limits of the current digital world are clear: money, data, and power are concentrated in the hands of the few, limiting opportunity and participation for most, and leaving the internet as a whole a less diverse, creative, and innovative space. It was never meant to be like this. But, as with so many things, we get so used to the way things are that we often stop seeing them. That is, until they break. - -## The rise of digital gold - -The financial crisis of 2008 was exactly this kind of breaking point. We saw with painful clarity the limits of our current financial system, the impossibility of fully trusting financial institutions, and the need to be able to be custodians of our money in a way that was accessible to everyone. Enter Bitcoin. - -With Bitcoin’s launch in 2009 a new, imagined but previously unrealized, horizon opened up. We were presented with a truly global currency that required no intermediaries, no bank account, and no government intervention or regulation. It was a community driven currency open to everyone regardless of wealth, social status, or national origin. - -Unfortunately, as with many young technologies, a combination of technical limitations and bad actors led Bitcoin’s adoption to remain limited early on. Slow transactions, complicated UX, and limited ways to use the token, along with its early reputation for being primarily for illicit activities, proved to be challenging hurdles for Bitcoin. So, while it remained in the popular imagination it did not reach the mainstream or its world changing potential. - -## The birth of the global commons - -Six years after Bitcoin’s initial launch, the second major player in the blockchain space came into being. Unlike Bitcoin, Ethereum wasn’t meant to only be about money, it was intended to be a global commons where people could build everything from currency to identity and governance systems. It was, in a sense, a global computer, but much like Bitcoin, one that was initially held back by its own technological limitations. The UX was equally complicated, and it required learning new conceptual frameworks and programming languages. - -If we fast forward to today, numerous other layer 1 blockchains, as well as layer 2s and layer 3s have arisen, but Bitcoin and Ethereum remain the largest and most important projects in the Web3 space, and in many ways the greatest hopes for bringing this world changing technology to everyone. And this is where Starknet comes in. - -## Web3 at scale - -Although it was originally launched on Ethereum, Starknet wasn’t built only for Ethereum. Starknet was built to be able to scale any chain using STARK proofs in order to create a digital world with integrity thanks to full verifiability. The idea that this would be possible for Bitcoin as well has been there from the very beginning of the project. Now, after countless hours of research and development, we are in a place to begin making this idea a reality. - -That this is now possible, and that Starknet is building the infrastructure and partnerships needed to make this happen is a massive step forward, and a reason to be excited. But what is perhaps even more exciting is what this will enable and what it can mean for the digital world as a whole. - -## A new foundation for the digital world - -By enabling developers to create applications that only need to be built once, using the same code, but that can settle on either Bitcoin or Ethereum, we will enable greater utility for Bitcoin and continue to make Ethereum’s digital commons more accessible to everyone through faster transactions, increased scale, and lower costs. For the first time developers will have true optionality between the leading chains, and can access the strengths of both Ethereum and Bitcoin depending on the application being built. - -Satoshi’s original vision was a digital peer-to-peer payment system that can operate without the need for centralized authority, at scale. Until now, only part of that was possible. By bringing STARK technology to Bitcoin, we are helping to make the full vision a reality. This can bring about a sea change in financial accessibility and inclusion, open up new markets, and create a new foundation for reimagining and reinventing the digital world from the ground up, something that resonates with both Satoshi’s vision as well as our own at Starknet Foundation. - -We are on the precipice of something amazing, and Starknet is leading the way. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Introducing Garden on Starknet: A direct path for BTC bridging - - Garden is live on Starknet, offering a direct path for Bitcoin liquidity. Bridge Bitcoin to Starknet with Garden for fast, low-fee DeFi. - - April 29, 2025 - -- #### Atomiq brings wBTC to Starknet, enabling Bitcoin DeFi - - BTC-to-wBTC swaps are now live on Starknet using onchain escrows and Bitcoin PoW validation, with no bridges or custodians. - - April 16, 2025 - -- #### Starknet over Bitcoin: Vitalik, Dan Held, and Jeremy Rubin react - - Starknet will become the first Layer 2 to settle on Bitcoin. Learn what Vitalik Buterin and two Bitcoin OGs think about the move. - - March 30, 2025 - -- #### Bitcoin Lightning Network payments with STRK—now live on Starknet via Braavos - - Braavos now enables Bitcoin Lightning Network payments with STRK on Starknet—no BTC, no extra setup, just tap and pay - - March 13, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/begin-your-startup-journey-with-founder-basecamp/ - ---- - -## Begin your startup journey with Founder Basecamp | Starknet - -Home  /  Blog - -Mar 5, 2025 · 2 min read - -Starting your own business can seem challenging, especially if you’re new to entrepreneurship. You might have a great idea, but figuring out where to start can be overwhelming. Founder Basecamp is here to help you turn those initial thoughts into a real, actionable startup plan. Through four interactive weekly sessions and a final pitch competition, Founder Basecamp will help you shape your idea, craft a compelling pitch, and confidently engage potential customers and investors. - -Whether you’re starting from scratch, have a basic concept, or need guidance shaping your vision, Founder Basecamp is the perfect place to begin your journey. - -Apply now → - -## Why join Founder Basecamp? - -Every successful startup begins with a simple idea. But making that idea clear, convincing, and appealing to customers and investors is tough. Many entrepreneurs stumble due to unclear messaging, poor market validation, or ineffective go-to-market strategies. Founder Basecamp offers you practical support and expert advice to help you transform your initial thoughts into a strong business concept. You’ll learn how to clearly communicate your idea, prove its value to real people, and gain the skills needed to attract funding. - -By participating, you will: - -- Turn your initial idea into a clear and compelling business concept. -- Learn how to validate your idea with real-world insights. -- Build the skills needed to successfully fundraise. -- Gain confidence and clarity to take your startup forward. - -## Who should apply? - -Founder Basecamp is perfect if you: - -- **Are an aspiring entrepreneur** — You’re driven to create something great but need structured guidance to figure out exactly what that could be. -- **Have an existing idea** — You’re clear about what you want to build but need help communicating it effectively to customers and investors. -- **Want to brush up on your entrepreneurial skills** — You’re interested in entrepreneurship and want to sharpen your startup knowledge and pitching abilities. - -## Program Overview - -### Week 1: Idea Refinement & Market Validation - -- Clearly define the problem your startup solves. -- Validate your solution through research and user feedback. -- Set clear, achievable goals to measure your progress. - -### Week 2: Go-To-Market Strategy & Marketing - -- Discover what makes your idea unique and appealing. -- Create a simple plan to attract your first customers. -- Develop clear messaging that excites your target audience. - -### Week 3: Fundraising Fundamentals - -- Understand the fundraising landscape. -- Create an impressive pitch deck to convince investors. -- Practice confidently answering common investor questions. - -### Week 4: Crafting and Perfecting Your Pitch - -- Refine your storytelling techniques to clearly share your startup idea. -- Learn how to use visuals effectively in presentations. -- Practice your pitch with peer feedback for refinement and confidence. - -### Week 5: Pitch Competition - -- Present your idea live to a panel of judges. -- Receive valuable feedback. -- Build confidence for future investor conversations. - -## After the program - -Completing Founder Basecamp isn’t the end! It’s just the beginning. The strongest pitches will earn the opportunity to team up with top technical co-founders from the Starknet ecosystem, entering a product-focused hackathon. This is your chance to rapidly prototype, validate your concept, and lay a solid foundation for your startup’s success. - -## Ready to get started? - -Now is the perfect time to move forward with your startup idea. Founder Basecamp provides the support, community, and practical steps you need to turn your idea into reality. - -Apply now → - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### DeFi Spring Program 2.0 - - Discover how to earn additional yield as a liquidity provider on Starknet with DeFi Spring 2.0. - - October 20, 2024 - -- #### Leadership transition at Starknet Foundation - - Diego Oliva, who has served as the first CEO of the Starknet Foundation will be stepping down and James Strudwick will be assuming the… - - August 6, 2024 - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/what-its-like-to-work-at-the-starknet-foundation/ - ---- - -## What It’s Like to Work at the Starknet Foundation | Starknet - -Home  /  Blog - -Jan 29, 2025 · 3 min read - -## A different kind of foundation, a different kind of job - -Working at the Starknet Foundation isn’t like any other job. It’s a chance to do something that matters, challenge yourself, leave your mark on an ecosystem that is out to reinvent the digital world, and work with some of the brightest minds in the field. - -With a leadership team with nearly 40 years of collective experience in Web3 ranging from lecturers in blockchain technology, to DeFi experts, to startup founders, to government advisors, to some of the most experienced product people in the field, the Starknet Foundation is a truly unique place to grow a career. - -## Not just another protocol - -Founded by pioneers in cryptography including Eli Ben-Sasson who developed groundbreaking innovations including zk-STARKs and Cairo — the L2 smart contract language — Starknet was launched in 2021 to not only overcome the current technical limitations of Web3, but open new ways to build impactful products that solve real world problems with integrity. This allows founders and developers to think beyond the boundaries of both Web2 and Web3 to bring their most ambitious and creative ideas to life, while making widespread adoption a real possibility through native account abstraction and improved UX. - -Starknet doesn’t simply make Web3 better by making it faster, more efficient, more scalable, and more cost effective, though it does all of those things as well, it fundamentally does something different. Starknet provides a future proof, fully verifiable development platform with its own complete programming language, with the aim of allowing founders and developers unmatched creativity and opportunity. Think of it as a new platform for the digital world, built on verifiability, that can push back against ever growing corporate control and the centralization of power, so we can once again trust the products we use and information we receive. - -Currently the digital world is built to benefit the few by centralizing opportunity and creating a divide between builders and users. Starknet is helping to turn this on its head. Founders get new paths to monetization, distribution, and discovery that build relationships with users and invite them into the life of their projects. Developers get access to a technology stack that unlocks new ways to imagine app development. While users get a range of experiences that aren’t available anywhere else. And all of this is backed by a supportive ecosystem filled with bright and creative minds, funding opportunities, and everything founders and developers need to turn their ideas into sustainable businesses. - -Starknet is the platform for those looking to reinvent everything. From gaming to finance, Starknet’s vision is to build the foundation for a new digital world that increases creativity, opportunity, and participation. - -## Life at the Foundation - -To work at the Foundation is to go beyond the traditional borders of a company. Our impact and reach extends across an entire ecosystem of entrepreneurs and builders, each of whom are at the forefront of their fields, giving everyone who works with us the chance to engage with a broad range of projects that are laying the groundwork for a new digital world. - -We understand that what we are aiming for isn’t small, and that there is no quick path to success, But, by living our values of integrity, long-term thinking, transparency, collaboration, creativity, and purpose in everything we do, we are well positioned to ensure this happens. - -Aligned with our ecosystem entrepreneurs, the culture at the Foundation is dynamic, entrepreneurial, and always evolving. To work here is to know you are making a real difference, having impact, not just on one project or company, but on an entire continually evolving ecosystem. - -Interested in making an impact on an entire ecosystem, and helping to reinvent the digital world? Find your place on the team. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/dont-stop-hodling-introducing-asset-runes/ - ---- - -## Don’t stop HODLing - Introducing Asset Runes | Starknet - -Home  /  Blog - -May 27, 2025 · 2 min read - -### **TL;DR** - -**You can now get native exposure to USDC on Bitcoin, unlocking trust-minimized interaction with the largest and most traded currency.** - -Bitcoiners face a dilemma: the security of Bitcoin vs. the expressibility and composability of other chains. Bitcoiners who sought financial functions such as exposure to other assets were thus forced to explore the broader blockchain sphere, thus compromising in leaving Bitcoin to other, less secure networks to achieve that. - -Enter Asset Runes – a new class of Bitcoin-native assets that are redeemable 1:1 for real-world assets, natively available within Bitcoin, starting with USDC. Explore Asset Runes: - -## **HODL Bitcoin, Use Asset Runes** - -With Asset Runes, HODLers can now diversify their portfolios without leaving the Bitcoin network, starting with USDC and expanding in the future to USDT, ETH, SOL, STRK and many more. Asset Runes are powered by: - -1. Starknet, Ethereum’s leading ZK rollup -2. The Bitcoin<>Starknet Runes Bridge – enabling a secure connection between Bitcoin and Starknet - -## **How it works:** - -In a nutshell, Asset Runes can be bridged to Starknet and then redeemed via smart contracts for the underlying assets in a 1:1 ratio. Let’s give a slightly more detailed overview. - -- Users hold USDC•Starknet directly on Bitcoin. -- USDC•Starknet acts like any other rune, which can be traded trustlessly on Bitcoin mainnet. You can try them out on DotSwap. -- Full reserves: each Asset Rune is backed 1:1 by an actual asset on Starknet. For example, each USDC Rune has a locked counterpart on Starknet. By design, it is impossible for the supply of Asset Runes on Bitcoin to exceed the reserves on Starknet. -- The Bitcoin<>Starknet Runes Bridge, secured by a federation of Bitcoin OGs (you can read all about the validators here), facilitates the secure transfer of funds between the networks. -- Once bridged to Starknet, users can redeem the wrapped Runes for the underlying asset at a 1:1 ratio without any trusted intermediaries. -- In the upcoming weeks, the StarkGate UI will abstract the intermediate wrapper from users, allowing for direct redemption from Bitcoin. Various applications will also integrate with StarkGate, providing the same UX. All are to be announced soon. - -## **More than Asset Runes** - -With ZK tech infrastructure, scale, native account abstraction, and a vibrant ecosystem, Starknet is the ideal candidate for enriching the financial offering for Bitcoiners. - -Asset Runes are an example, with Starknet providing a redemption layer. However, Starknet is also ideally positioned as an arena for asset and value creation: whether you want launchpads or DeFi. - -## **Try Asset Runes Today** - -Open your Xverse wallet, or try them on DotSwap!  - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-foundation-delegation-program/ - ---- - -## Starknet Foundation Delegation Program: How to apply - -Home  /  Blog - -Jul 17, 2025 · 3 min read - -As Starknet continues its decentralization journey and moves closer towards a Proof of Stake (PoS) protocol, contributors across the ecosystem are working together to support the growth of a strong, decentralized validator set. This is a critical bootstrapping moment: wide participation in staking and validation is imperative to safeguarding the network against the undue influence of any single entity, which is essential for a strong, permissionless, and truly decentralized system. - -Delegation programs play a key role in this process by lowering the barrier to entry for validators, encouraging broader participation, and improving decentralization. - -## The Starknet Foundation Delegation Program - -This week, the Starknet Foundation launched the Starknet Foundation Delegation Program (SFDP), a strategic initiative designed to enhance staking distribution, support validator growth and diversity, and strengthen network resilience. - -The program creates new opportunities for both new and existing validators to participate in securing the network. As such, there is clear, meaningful support and well-defined performance benchmarks. - -Let’s take a closer look at how the program works, who it supports, and what to expect. - -## Program details - -At its core, the Starknet Foundation Delegation Program is about broadening participation and improving resilience. Starknet’s validator set has grown, but we can and should do better for the health of the network and ecosystem. The program addresses the growth of staking delegation by introducing delegation mechanics and targeted validator support. - -The program’s goals are clear: distribute stake across a more diverse validator set; increase the number of active validators securing the network; upgrade overall staking participation to improve network security in the long-term. - -And it does this with a design philosophy built around three principles: - -- **Fair** – Balance decentralisation goals with responsible treasury management -- **Targeted** – Prioritise measurable, meaningful outcomes -- **Flexible** – Built to evolve alongside the network and its needs - -## How it works - -The Foundation will match validator stake 1:1, up to a maximum of 5 million STRK per participant, subject to performance criteria, such as: - -- **Stake Matching:** For STRK staked by a validator, the Foundation will delegate the same amount (up to 5M STRK), excluding any amount received from other Delegation Programs. -- **Residual Delegation**: Any remaining STRK in the delegation pool may be distributed evenly amongst qualified participants, i.e. - -- Stake 30M STRK → receive 5M delegated STRK matched + residual share. -- Stake 1M STRK → receive 1M delegated STRK matched + residual share. - -- **Program Cap:** If the delegation pool is exhausted, the Foundation will reduce stake matching allocations to all validators by the same proportional percentage. - -These mechanisms support validators who have secured meaningful stake independently, while also encouraging new participants to grow with the ecosystem. - -### Who is eligible? - -To receive matched delegation, validators must: - -- Run a full Starknet validator node. -- Maintain high uptime (>99%) and responsiveness. -- Respond to Foundation inquiries within 48 hours. -- Set commission rates at 10% or less. -- Meet regulatory compliance requirements - -**Validators remain eligible even if they participate in other Delegation Programs; however, any delegation received through those programs will be excluded from the matched stake calculation**. Validator performance will be monitored continuously, and delegated amounts will be adjusted regularly. - -### Application - -To apply, fill out the Starknet Foundation Delegation Program application form. Reviews will take place on a rolling basis. - -## Designed with adaptability in mind - -The program is built to adapt. During the program’s rollout, community feedback will be ensured with clear, transparent communication from the Foundation. - -## What are the next steps? - -The Starknet Foundation Delegation Program is an important moment in Starknet’s path toward deeper decentralization. It’s not just a validator incentive, it’s a strong signal to our ecosystem that STRK is here to do more. - -If you’re a validator – or ready to become one – now is the time to join us in building a more diverse and resilient Starknet. - -If you apply to the Starket Foundation Delegation Program, stay tuned to your inbox for updates from the Starknet Foundation. - -Let’s build a more resilient Starknet, and reshape the digital world together. - -_Note: This program does not constitute a grant, investment, or form of compensation. Delegated STRK remains under Foundation custody and is subject to revocation based on validator behavior. The program operates at the sole discretion of the Foundation and may be modified at any time to promote broader inclusion, fairness, and alignment with ecosystem goals._ - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/blurb-on-liquidity/ - ---- - -## Blurb on Liquidity: Understanding DeFi Market Dynamics | Starknet - -Home  /  Blog - -Written By: Ilia Volokh - -Aug 10, 2025 · 12 min read - -This post attempts to organize a basic understanding of liquidity, oriented at DeFi. We’ll define liquidity and its key metrics, and analyze it for constant-product AMMs. Then we’ll touch on impermanent loss and end with a brief overview of concentrated liquidity. - -# Liquidity - -Liquidity is a property of markets, crucial for capital efficiency. Folklore intuition can be summed up in one line: - -> A market is liquid if it can quickly execute trades with minimal price changes. - -For example, major stock exchanges are liquid markets for commonly traded stocks. - -It is typical to abuse terminology and say an asset is liquid, meaning “this asset is quickly convertible into money with minimal loss”. Formally, this statement asserts the liquidity of an implicit market between the asset and money. For examples, a house is an illiquid asset because it takes a while both to discover the market price and to sell it at that price. - -One sometimes encounters the term “funding liquidity”, referring to the ease of obtaining credit (i.e., borrowing). Thus an asset has high funding liquidity if it can serve as collateral for money at a good rate. - -For some history see e.g. this stackexchange answer. - -Liquidity is measurable by a few key metrics: - -| Metric | Meaning | Consequence | Cause | -| ------------ | --------------------------------------------------------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------- | -| Spread | Lowest sell price (best ask) minus highest buy price (best bid). | Wide spread → high cost to initiate trade | Insufficient market-making | -| Depth | What asset amount can be traded within some price range? | Shallow depth → volatility | Insufficient supply | -| Price impact | How does my trade impact the current market state? | High price impact → I get less | App-level: depth & spread | -| Slippage | What I expected when placing my trade vs what I got when it executed. | High slippage → I get less | Core-level: market state discrepancy between simulation & execution, e.g. due to competition, latency, MEV | - -Spread is a threshold cost which dominates small trades. Larger trades begin to consume depth, which outweighs the initial spread. - -Before diving a bit deeper, we record a common unit of measurement in finance: - -**Definition.** A basis point (plural bps) is a hundredth of a percent $0.01\%=\frac{1}{10,000}$. - -## Spread - -Assuming the market price is within spread interval, a taker must pay a premium to immediately initiate a trade. Wider spread → higher premium. - -[highest bid,lowest ask] - -A narrow spread thus increases capital efficiency, especially for small trades. A spread of 10 bps means the highest bid and lowest ask differ by $0.10\%$. - -## Depth - -High depth around an exchange rate leads to price stability: even large trades will not cause volatility. The statement “there’s 10K USD of BTC buy-side depth per bp at the current price” means you can buy 10K USD-worth of BTC and incur a price change of at most one basis point, i.e $0.01\%$. - -The depth of liquidity in a price interval should be thought of as the supply of capital deployed there. High depth at exorbitantly high/low prices is wasted capital. We’ll unpack this later for constant-product AMMs. - -Depth is also crucial for stable capital-efficient loan markets because it ensures liquidations are profitable to liquidators. We illustrate the opposite extreme: how shallow depth triggers a liquidation death spiral. The loan market in question is borrowing USD against BTC collateral. - -- Suppose Alice loaned 1M USD to Bob against 10 BTC. Suppose Bob defaults, so that Alice seizes 10 BTC. Now suppose Alice wishes to liquidate the loan i.e. sell the BTC for USD. If the BTC/USD market in question has shallow liquidity, the exchange rate would dip against Alice: she may sell 1 BTC at a good price, but any larger amount would sell at an increasing loss to her. In case of an over-collateralized loan, Alice can make a quick profit even if she sells some of her BTC underpriced. Such a sale would lower the BTC/USD exchange rate against BTC, potentially triggering more liquidations. -- Depth is the dampener of liquidations, defending against chain-reactions and death spirals. - -## Price impact - -Products sold in stores typically have posted prices, which trivialize economic calculation. The naive approach to buying some amount of an asset would be to multiply its market price-per-unit by the amount. - -If the market price is a 1 USD/unit, I naively expect 100 USD to buy me 100 units. _Price impact_ is any deviation from this expected outcome. Such deviations are deterministic in the current market state, and determined entirely by trade size, spread, and depth. Price impact can be mitigated at the application level, e.g. via aggregators and routers which traverse multiple markets. - -## Slippage - -Even if I have perfect knowledge of the market mechanism (e.g. AMM curve) and its current state, I do not know the future market state at the execution of my order. Despite my ability to perfectly simulate my trade, I cannot predict the market conditions at execution: reality can differ from my expectations, resulting in _slippage_. Such slippage can be honest, e.g. competitors pay higher priority fees and overtake me, or manipulative, e.g. sequencers manipulating ordering. - -# Market-makers - -Markets are not in a constant state of equilibrium, and organic activity (or lack thereof) can result in occasional wide spreads. - -1. Buyers and sellers need not show up together. There can be waves of one-sided demand, in terms of both time and volume. -2. Price discovery takes time: buyers would initially post low bids and sellers would initially post high asks. -3. Liquidity may not arise organically, due to wide spreads or shallow depth. - -Market makers (henceforth MMs) streamline market operations by providing supply & demand counterparties and optimizing price discovery. - -## Order-book market-makers - -In order-book markets, MMs act by posting trades that bring the market closer to equilibrium. The naive business model is simple: manufacture spread and profit off it. Specifically, MMs manufacture spread by maintaining a gap between their highest bids and lowest asks. They aim for a narrow spread when competition is high and risk is low, and conversely. Let’s make this a bit more explicit. Assume Alice and Bob are competing MMs. If Alice quotes (posts orders) slightly tighter than Bob, then her orders are more attractive to traders, and they’ll get executed first. This is obviously good if she profits, but a volatile market may actually cause tight spread to incur losses. - -Although MMs profit off of wider spread, a competitive market also incentivizes them to provide _depth_ around their _tightest_ quotes. Indeed, once demand depletes Alice’s tightest quotes, she no longer has any competitive advantage over Bob. The more depth she provides, the more orders she will be able to capture from Bob at her tighter spread (despite profiting less per unit exchanged). - -To summarize, order-book market-makers are precisely liquidity providers! - -## AMMs; impermanent loss - -An AMM is an implementation of a market that: - -1. Automatically computes exchange rates based on its state. -2. Automatically distributes supply across the exchange-rate curve to create liquidity. - -Since AMMs automatically manage capital, the only _required_ making is the deployment of capital. It so happens that AMM terminology refers to these capitalists as liquidity providers. As we shall see below, more refined AMM designs actually involve makers who choose where to deploy capital, i.e. where to create depth. In this sense, they are indeed liquidity providers as opposed to “mere capitalists”. - -Before continuing, we’ll define an important concept that is often overcomplicated by only looking at examples. - -**Definition.** A pair (LP position, initial deposit) is at _impermanent loss_ if the current the value of the LP position is lower than the current value of the initial deposit (i.e. at current exchange rates). - -To emphasize – impermanent loss is only defined with respect to an initial deposit; it’s not an intrinsic property of an LP position. Put succinctly, impermanent loss is the opportunity cost of being an LP instead of holding on to the capital in a wallet. This opportunity cost if offset by expected profit from trading fees. - -Impermanent loss is so-called because it may be transient. It is caused by arbitrage traders reacting to market shifts: - -1. The market outside the AMM shifts, affecting the market exchange rate between the AMM assets. -2. Arbitrage traders buy the appreciated asset from the AMM for cheaper than on the external market. -3. The AMM supply of the appreciated asset decreases until the AMM discovers market price. -4. If an LP redeems their share of each asset, they end up with a smaller amount of the appreciated asset than they deposited, but a larger amount of the depreciated asset. -5. The current value of the redeemed LP position is lower than the current value of the original deposit. - -Risk of impermanent loss vanishes once AMM exchange rates return to the neighborhood of the initial deposit. For this reason, it is customary for volatile pair LPs to charge higher fees. - -The above formulation should make it clear there is no “impermanent gain” – arbitrage traders buy whichever asset is undervalued by the AMM. - -# Worked example: constant-product AMMs - -We now illustrate the abstract nonsense above in the setting of a constant-product AMM. We start out **without fees**, and address them later. - -## Basics - -Fix two assets $X,Y$ and denote by $x,y$ their respective supplies. The AMM curve is $xy=k$ for some constant $k$. Evidently the curve is symmetric in $x,y$. As a function of $x$, we see $y=\tfrac kx$ is not only monotone decreasing but also _subadditive_, which enforces diminishing marginal utility. Conceptually, this is the only required property of an AMM curve. In our constant-product case, marginal diminution is visualized by the hyperbola curve: As the supply $x$ grows, a fixed change of supply $\Delta x$ causes a diminishing change of supply $\Delta y$. - -Let us quantify supply changes. Suppose the present state of AMM supply is $x,y$. How does a change in supply $\Delta x$ affect the supply of $Y$? By definition, the next state of the AMM supply is $x+\Delta x, y+\Delta y$, so the invariant constraint gives us - -Hence - -Thus we see how $\Delta y$ inversely depends on the initial supply $x$. - -The exchange rate (price) charged by the AMM is just the ratio of supplies. The fraction $\frac{y}{x}$ is the supply of $Y$ fitting into a unit supply of $X$. That is, the $Y$-price of a unit of $X$. Price change is easily computable: - -Note the $Y$-price of a unit of $X$ obeys an inverse square law w.r.t to the supply of $X$: price decays quadratically as supply grows. This super-linear decay also exhibits diminishing marginal utility. - -Prices are not encoded by the AMM equation, but rather discovered by the market. The equation merely constrains the supplies to satisfy diminishing marginal utility, which is necessary for price discovery. (Play around with a constant-sum equation and see how the resulting market is severely misbehaved. Hint: the exchange ratio must be 1:1, so no diminishing marginal utility and therefore no price discovery and the pool is easy to drain.) - -## Depth analysis - -In this section we’ll quantitatively analyze the depth in constant-product AMMs. Our goal is to answer questions like “what percent of the supply is employed for trading within a given price range”. - -We can express supply $x$ as a function of the $Y$-price per unit of $X$: $p=\frac yx$. - -Note a larger constant $k$ means more depth: the market sustains a larger supply of $X$ at a given price. - -By definition, depth is the supply change required to move between given prices. - -Depth is nonnegative iff $p\_1\leq p\_2$: supply decreases iff price increases (in this AMM). Evidently depth is antisymmetric, so the price interval determines a unique number – the absolute value of the associated depth. Note also how depth scales with the interval: - -> Constant-product AMM depth decays slowly as $\frac1\surd$. - -Equipped with the depth formula, we can analyze the capital efficiency of constant-product AMMs. Specifically, we’ll analyze how the constant product curve causes supply to be inefficiently allocated to price bands with low trading activity. - -### Depth on the tail - -Assume a current supply of $x\_0$ at a price-per-unit of $p\_0$. This supply is distributed over the price range $[p\_0,\infty)$ precisely according to depth. - -- A divergent increasing sequence of prices $p\_0 The partition of total current supply by depth specifies the amount of current supply allocated to each price band. - -How much supply is “wasted” on exorbitantly high prices? Consider a $\overbrace{\text{USDC}}^Y/\overbrace{\text{ETH}}^X$ pool with $k=10^{10}$. As of July 2025, 1 ETH ≈ 3000 USD, so $p\_0=3000$ whence $x\_0=\sqrt\frac{10^{10}}{3000}\approx 1825$. A high USD-price of ETH is denoted $p\_\top$. The depth formula gives - -Some example computations show the extreme capital inefficiency of the constant-product curve. - -### - -### Depth in general - -How to interpret $D\_X(p\_1\to p\_2)$ if the current price $p\_\text{now}$ satisfies $p\_\text{now}>p\_1$? In this case, reaching $p\_1$ would require an increase in supply, so we can’t use the partition trick above. Or can we? Math shows the way. The equation - -interprets the LHS as the amount of supply required for a price increase $p\_1\nearrow p\_\text{now}$, plus the (familiar) depth starting from the current price. - -### Depth concentration - -We can write an explicit formula for the relative depth concentration in a price band within a larger band $[p\_1,p\_2]\subset [p\_\perp,p\_\top]$, notably independent of the constant $k$. - -Let’s analyze the capital efficiency of a constant-product AMM for a **stable pair** USDC/USDT. by looking at the relative concentration of a bp interval vs a 1% interval (factor of 100) - -So assuming the entire market lives within a 10% band, merely 10% of capital is allocated to trading within a %1 band, and merely 1% is allocated to trading within a basis point! - -## Impermanent loss - -Consider an ETH/USDC pool with initial supply of 100 ETH and 100K USDC, so initial ETH price is 1000 USDC and the constant is $k=10^7$. Now assume ETH price doubled to 2000 USD on the outside. Traders flock in to buy the underpriced ETH from the AMM. We compute the ETH reserves at the end of price discovery, when the AMM price has stabilized at 2000 USDC per ETH: - -Suppose Alice initially owned 10% of the pool. - -- Her initial deposit was 10 ETH and 10K USDC. Current value = 30,000 USD. -- Her current LP position is 7.071 ETH and 14,142 USDC. Value $\approx$ 28,284 USD. - -## What about fees? - -Percentage fees are crucial for LP revenue. They slightly increase price impact, especially for larger trades. - -# Concentrated liquidity - -Classically, there is a clear distinction between capitalists, who passively provide capital, and those who actively employ capital (often delegated to them). In DeFi terminology, capitalists are the _passive_ liquidity providers. However, _active_ liquidity providers are superior market makers, who have strong potential to enhance capital efficiency. We illustrate this with a case study: Uniswap v2 vs Uniswap v3. - -Uniswap v2 is a constant-product AMM. LP UX is roughly: choose pair → deposit assets → receive LP token → earn fees → exit. LPs must supply equal value of both tokens (to preserve pool price). Since LP positioned are fully determined by deposited capital, LP tokens are just fungible ERC-20 tokens. - -Uniswap v3 is a “piecewise-constant-product” AMM. LP UX is roughly: choose pair → choose fee tier → choose price range → deposit assets → receive LP token → earn fees → reposition/exit. Each pool partitions the allowed price range via _ticks_, via which LPs can specify their desired price bands for deploying capital (adding depth). Due to the added complexity of the liquidity position, LP tokens are (currently) NFTs, encoding more than the ERC-20 standard allows. - -The ability to concentrate capital in a chosen price range precisely means LPs are free to choose where to provide depth. Let’s illustrate how beneficial this design is for capital efficiency by examining a stable pair, e.g. USDC/USDT (I wonder how well this will age). The vast majority of LPs will choose to provide depth in a narrow band about the 1:1 rate, so liquidity will be deep in the center and shallow at de-pegged exchange rates. If Alice deposits in tick range $[t\_1,t\_3]$ and Bob deposits in $[t\_2,t\_4]$, both are active in $[t\_2,t\_3]$, and both provide liquidity to the constant-product AMM associated to this small interval. The locality of each piece in Uniswap v3 mitigates the slow $\frac1\surd$ decay of depth in constant-product AMMs to small intervals. - -Unfortunately the piecewise design has a significant drawback: it exacerbates the risk of impermanent loss. For example, assume Alice concentrates her capital at in the range $[2900,3100]$ USD per ETH. Suppose ETH begins tp appreciate with respect to USD in the outside market. As usual, arbitrage traders buy the strong asset (ETH) from the pool. However, since Alice concentrated all her capital in this narrow range, if ETH appreciates beyond the interval, her entire initial deposit of ETH would be depleted and exchange for USD due to arbitrage. In other words, the narrow price range makes Alice more susceptible to impermanent loss. As usual, if the price moves back in range, the impermanent loss vanishes, and Alice can continue her plans for world domination. - -In a sense, piecewise-constant-product AMMs interpolate between a constant-product AMM on one end, and an order-book in the other: liquidity providers act as market makers by choosing where to deploy capital. Concentrated liquidity assists price discovery due to aligned incentives: LPs earn trading fees when their deployed capital is used, so they naturally want to provide depth near market prices. Order-books still have some advantages: market-makers have room for more capital efficient strategies, and they’re not exposed to impermanent loss! - -The article was originally posted by Ilia on GitHub’s Unthoughts. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-grinta-the-architecture-of-a-more-decentralized-future/ - ---- - -## Starknet Grinta: Advancing Decentralization & L2 Performance - -Home  /  Blog - -Sep 1, 2025 · 3 min read - -## Introduction - -The newly released version of Starknet – previously referred to by its numerical version name v0.14.0 and now known as ‘Grinta’ – marks a major milestone in Starknet’s decentralization journey by distributing the sequencer architecture. While Starknet previously operated with a single sequencer, it now has three independent sequencers running consensus and taking turns building blocks. - -This version of Starknet also includes some important user-facing features, including subsecond pre-confirmations, a mempool, a fee market, and a standardized integration to paymaster, all of which are discussed below. - -## Strides toward Decentralization - -The biggest change introduced by Starknet Grinta is a decentralized sequencing architecture consisting of three sequencers running consensus. Trust minimization is one Starknet’s core values and decentralized sequencing is essential to ensuring neutral transaction inclusion and ordering. Together with Staking v2, which was introduced in June 2025, this version of Starknet is a significant step toward putting the necessary technical infrastructure in place for the next phases of decentralization. - -During this version, the operation and control of the sequencers is still centralized under StarkWare; however, according to Starknet’s decentralization roadmap, block validation and production are distributed between several nodes operated by StarkWare, with fully decentralized sequencing and proving to come in the future. Decentralization is a core requirement for a public blockchain, and for Starknet this will mean that protocol security is managed through transparent, community-driven mechanisms. - -## Additional Features - -### Pre-Confirmations - -Starknet Grinta introduces incredibly fast, subsecond pre-confirmations, which means users receive the transaction status much earlier than block publication. In other words, pre-confirmation is a promise by the block proposer that a transaction is part of the proposal submitted to the consensus. The advantages of pre-confirmations for users are significantly reduced latency and the ability to act on transactions before L2 finality. - -### Mempool - -Mempools are also being introduced to Starknet with Grinta. Mempools store transactions waiting to be added to a block. They are continuously updated by adding, holding, deleting, and replacing transactions that are received. Starknet’s sequencers’ mempools are connected in a p2p network, so they are synced about transactions within a fraction of a second when there is no congestion. - -### Fee Market - -Another new feature focused on future-proofing Starknet is a fee market on l2_gas. Prior to Grinta, the price of l2 gas was dependent on Ethereum’s gas price and, as a result, also affected by fluctuations on Ethereum. In addition, gas fees covered the “marginal” onchain cost of verification. However, due to significant technological improvements on Starknet, including advances in its proving stack and the introduction of blobs, onchain costs have become almost negligible. - -As Starknet moves toward decentralization, we are striving for a fee policy that incentivizes the participation of many sequencers. With this in mind, and together with feedback from the community, the minimum l2_gas base price is set at 3 gFri. This base price ensures that fees cover the operational costs when gas prices on Ethereum are low, while improving the scale and costs when gas prices on Ethereum are high. - -### Standardized Paymaster - -Another new feature introduced by Grinta is a standardized paymaster interface. While Starknet had a paymaster in earlier versions, the interface was not standardized. The standardized interface brings compatibility across different dapps and crypto wallets, allowing devs to integrate with any paymaster without the need for custom logic which would vary on a per-vendor basis. - -## What’s Coming Next? - -The remainder of 2025 will see Starknet continue on its journey of becoming a better-performing and more decentralized network. On the decentralization track, decentralized validation is planned. This means that stakers will participate in the consensus and will vote on blocks. At least two-thirds of the stake will be required to sign off on blocks in order for them to be finalized. Only sequencers operated by StarkWare will propose blocks at that stage, with full decentralization set for a future version. - -As for performance, Starknet will move beyond 1000 TPS with the introduction of Cairo Native and will significantly reduce proving costs through improvements to S-two. Additional features, including faster L1 finality, better block times, and more are currently under discussion with the community. - -The name Grinta – meaning grit, resolve, or determination – captures our resolve to make Starknet the manifestation of the blockchain vision: a high-performance and widely-adopted economic hub that doesn’t compromise on security or decentralization. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/global-payments-settled-fast-on-starknet-powered-by-due/ - ---- - -## Global Payments, Settled Fast on Starknet - Powered by Due - -Home  /  Blog - -Sep 4, 2025 · 2 min read - -## Introducing Due - -We’re thrilled to announce the launch of Due on Starknet! Due is a cost-effective global payments solution on top of interoperable blockchains and stablecoins, enabling anyone globally to send and receive funds and make payments as if they were local. - -Due can be seamlessly connected to your Braavos and Ready wallets on Starknet or to dapps via Due’s API for on- and off-ramps, cross-border payments, remittances, and more. It is available in over 80 countries and supports more than 30 fiat currencies, as well as USDC, EURC, and USDT stablecoins, with more in the pipeline. - -Due offers multi-currency virtual accounts for businesses and individuals in USD, GBP, EUR, MXN, and more to send and receive funds directly between local or foreign fiat currencies and stablecoins. It also provides access to multiple local payment rails, including ACH, SEPA, and Brazilian Pix, among others. - -As for security, Due is built with SOC 2-grade controls, provides real-time risk monitoring, and automated KYC/KYB, and is operated through licensed and regulated partners globally. - -This integration enables Starknet users globally to on- and off-ramp funds from USDC or USDT and send funds to bank accounts, mobile wallets, or directly to stablecoins. All Due transactions settle in under 24 hours, and, in the case of stablecoins, instantly, removing friction and unlocking new levels of financial inclusion. - -## What Sets Due Apart - -**Due offers incredibly low fees [1]:** - -- 0.2-0.5% on average vs the standard 4-6% for conversion rates. -- Wires that are 5-10 times cheaper than traditional wires. -- Free USDC transfers. -- USDC <> USDT 1:1 swaps with zero slippage. - -**In addition to being cheap, Due offers users virtual local accounts at no cost:** - -- Virtual accounts provide local payment details unique to each user’s account that can be used to receive payments locally. -- This allows individuals and businesses to receive payments without ever having to open a local bank account. - -**While Due users can easily connect their Starknet wallets, Due also allows users to open digital non-custodial crypto wallets with biometric key access.** - -- The wallets function like onchain accounts and instantly convert fiat payments to stablecoins that can then be held in the wallet. -- Users can manage multiple digital currencies no matter where they are. - -## Start Using Due Today - -- Sign up at app.due.network -- Create your Vault or connect an existing wallet to store your funds -- Verify your account -- Start moving your money! - -For more information, visit https://www.opendue.com/. - -This is not investment advice and this information is subject to change. Please do your own research and see terms and conditions here. - ---- - -[1] https://www.gsma.com/solutions-and-impact/connectivity-for-good/mobile-for-development/wp-content/uploads/2024/12/Cross-border-Mobile-Money-Remittance-Cost-Survey.pdf?utm\_source=chatgpt.com - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-starter-pack/ - ---- - -## Starknet Starter Pack: Your Guide to the ZK Rollup Ecosystem - -Home  /  Blog - -The Starknet ecosystem is evolving fast. With Starktember live and the BTCfi campaign launching soon, it's easy to feel overwhelmed by everything happening at once. - -Written by: Lyskey - -Sep 4, 2025 · 20 min read - -This starter pack is here to guide you: a complete overview of what you can do on Starknet today, and how to get started on mainnet right now. - -It covers everything you need, and even includes some alpha on how to make the most of Starknet. Whether you’re into **DeFi, gaming, content creation, or yield farming**, this guide is designed for you. - -## **Why Starknet?** - -What makes Starknet different from other Layer 2s? Before diving into this starter pack, let’s quickly cover **why Starknet exists**. I’ll keep it short, I’ve already written a full article on this topic if you want to go deeper. Most blockchains force you to choose: - -- Fast and cheap **or** decentralized and secure -- Easy to use **or** truly trustless - -Starknet exists to **end that trade-off**. Built from scratch with a new VM, a new proof system, and a new UX model, it delivers **all three pillars of the blockchain trilemma at once.** - -### **Scale without compromise** - -High throughput, low latency, and fees that decrease as usage grows; all while inheriting Ethereum-level security. - -Today, Starknet handles **1,000+ TPS**, with average confirmations in **~500 ms** and fees as **low as $0.002**. - -And this is only the beginning: capacity will scale beyond **10,000 TPS**, while latency keeps dropping over time. - -### **Decentralization & Security by Design** - -As a Layer 2 that settles on Ethereum, Starknet naturally inherits Ethereum’s decentralization and security. But unlike other L2s, Starknet achieves this **without compromise**: - -- It is the only ZK Rollup in production with zero trust assumptions, powered by STARK proofs, a quantum-resistant system with no trusted setup, and already battle-tested on billions of transactions. -- Recognized by L2Beat as a Stage 1 Rollup, Starknet is on track to reach Stage 2 and become fully trustless. -- Progressive decentralization is already underway through STRK staking, soon to be complemented by BTC staking, positioning Starknet as the most decentralized and secure L2 stack. So, beyond inheriting Ethereum’s security and delivering high performance, Starknet is also on the path to becoming fully decentralized. - -### **Web2-grade UX** - -From day one, Starknet was built with **native Account Abstraction (AA)** at its core. - -That means users on Starknet don’t face the usual crypto friction. Here’s how that translates in practice: - -- **1-click everything** → Bundling transactions (approvals + actions) into one click saves time and confusion. No more “approve → confirm → sign again.” -- **Gasless transactions** → Users don’t need to juggle ETH or STRK for gas. Fees can be abstracted away or sponsored by apps, removing one of the biggest onboarding barriers. -- **2FA / 3FA security** → Multilayer authentication is native on Braavos and Ready wallets. So even if one device or key is compromised, your funds stay protected. -- **Social logins** → Forget seed phrases. With account abstraction, you can spin up a wallet using your Google, Discord, or other familiar logins, making wallets as easy to create as any Web2 account. -- **Session keys** → Enable smoother gameplay and dapp interactions by letting apps temporarily sign transactions on your behalf. That means zero pop-ups while interacting onchain, perfect for gaming and social use cases. - -### **Long-term alignment** - -Backed by a team (StarkWare) with a multi-cycle track record of shipping industry-defining tech. As the saying goes: a picture is worth a thousand words, so here’s one: - -In short, Starknet delivers the performance developers need, the UX users expect, and the integrity blockchains promise, all at once. - ---- - -## **How to Get Started on Starknet** - -If you already have a Starknet-compatible wallet with funds on it, you can skip this part and jump to the next Section. For everyone else 👇 - -### **1. Starknet Wallets** - -The first step to join the Starknet ecosystem is to download a crypto wallet. You have several options here, but note that Starknet is not EVM-compatible, which means downloading a native Starknet wallet will unlock the full power of the network: 2FA/3FA security, gasless UX, Session Keys, and more. - -Currently, you have 3 native Starknet wallet options: - -- **Ready** **(formerly Argent)** → Session Keys, 2FA, gasless UX on browser, gasfree on mobile, plus a debit card for real-world payments -- **Braavos** → 2FA/3FA for enhanced security, gasfree UX on mobile, an integrated DeFi hub, Lightning Network integration for real-world payments, and more -- **Cartridge Controller** → a gaming-focused wallet that delivers a Web2-like UX when playing most games on Starknet (no gas fees, no popups, social logins via Discord/Gmail, invisible wallet) - -In addition to native wallets, you can also use some leading wallets from other ecosystems: - -- **Xverse** → the leading Bitcoin wallet, allowing you to manage Bitcoin, Starknet, and other Bitcoin L2s from a single UI. Note: Starknet integration on this wallet is still in its early stages and not yet fully connected to the ecosystem, but it’s coming! -- **Keplr** → the leading Cosmos wallet -- **MetaMask Snap\*\***,\*\* **Bitget Wallet\*\***, and\*\* **Ledger** - -Finally, the ecosystem is actively working to remove the EVM bottleneck by making all EVM wallets (MetaMask, Rabby, Phantom, etc.) compatible with Starknet. The solution is Rosetta, not yet production-ready but hopefully coming soon, which will enable a **native Starknet experience directly inside MetaMask and other wallets.** - -Pick one of these available wallets, and you’re already halfway through your Starknet journey. - -Once your wallet is ready, the next step is to fund it. There are two possible situations: either you have no funds onchain and need to deposit fresh capital, or you already hold funds on other chains and want to bridge them over. - -Let’s start with the first case: on-ramping. - -### **2. Buy Crypto on Starknet with Credit Card or Deposit from CEX** - -You’ve got two options 👇 - -#### **a. Buy with Credit Card** - -The easiest option is to purchase crypto directly inside your wallet using a credit or debit card. - -- On **Braavos**, you can use **Transak, Ramp Network, and Banxa**. -- On **Ready**, you can use **Banxa**. - -This method is fast and simple: all you need is a wallet and a card. Funds usually arrive within minutes. - -#### **b. Deposit from a Centralized Exchange (CEX)** - -If you already hold crypto on a CEX, you can transfer it to your Starknet wallet. Supported CEXs include **Binance, KuCoin, OKX, Bybit, Biget, HTX,** **Crypto.com\*\***, Bithumb, Upbit, Gate, & MEXC.\*\* - -This option is often cheaper than buying with a credit card, especially for larger amounts. - -### **3. Bridge Crypto to Starknet (Ethereum, Bitcoin, Solana & more)** - -If you’re already an onchain trencher, you can bridge your funds from all other ecosystems directly into Starknet using the following options: - -- **StarkGate** → the canonical Starknet bridge, supporting: Ethereum ↔ Starknet, Bitcoin ↔ Starknet (for Runes assets), Solana ↔ Starknet -- Bitcoin-focused bridges: **Garden** and **Atomiq Labs**, connecting Starknet and Bitcoin. -- For all chains: **RocketX Exchange** connects Starknet with 180+ chains, offering deep liquidity via CEX routing (great for large transfers). Other options: **LayerSwap**, **Orbiter Finance**, **Rango**, **RhinoFi**, **RetroBridge**, **Owlto**, **Minibridge**. - -Note that other bridges are coming: - -- **Hyperlane** is now integrated with Starknet; new bridges are under development using this technology. -- Two major interoperability protocols are expected to launch in **Q4 2025**. - ---- - -## **Starknet DeFi Ecosystem** - -Starknet has one of the most diverse and fast-growing DeFi ecosystems in crypto. Whether you’re here to trade, farm yield, or experiment with new primitives, you’ll find advanced tools already live on mainnet. - -Let’s break it down 👇 - -_Note: A few other options exist (mySwap, 10kSwap, Hashstack…), but I won’t cover them here since they are essentially inactive or abandoned. Instead, I’ll focus on the projects that are active and delivering real value on Starknet._ - -### **1. Spot trading** - -If you want to trade spot on Starknet, you have plenty of options. - -#### **AVNU (Aggregator)** - -In my opinion, the best option is **AVNU**, a DEX aggregator that pulls liquidity from all available sources on Starknet: AMMs, CLOB DEXs, and market makers. It’s also the most integrated trading hub in the ecosystem, powering much of Starknet’s trading UX. - -By trading on AVNU, you get access to all pairs on Starknet and the best available rates in one place. You can trade with a simple swap interface or use **DCA (Dollar-Cost Averaging)** to spread your orders across time. Limit orders are also in the works as far as I know. - -AVNU additionally provides chart views with up to one year of history. - -#### **Fibrous (Aggregator)** - -Another aggregator is Fibrous Finance, also live on Base and Scroll. Like AVNU, it aggregates all liquidity sources on Starknet for best execution. In addition to a classic swap, Fibrous offers a batch trading feature that lets you swap multiple tokens (more than two) at once, in a single transaction. - -If you prefer trading directly on DEXs rather than aggregators, Starknet offers three options. - -#### **Ekubo (AMM)** - -Ekubo is the most advanced and efficient AMM in crypto. It lets you trade using: - -- **Swaps** for simplicity -- **DCA** to spread your orders over time -- **Limit orders** for precise execution - -#### **Layer Akira (CLOB DEX)** - -Layer Akira is a spot CLOB DEX that allows traders to swap with access to price charts, order book history, and visibility into how much liquidity sits at each price level. Limit orders are coming soon, enabling traders to buy or sell assets at very precise prices. - -#### **Remus (CLOB DEX)** - -Remus DEX is another spot CLOB DEX, aiming to provide the full spectrum of features usually available on CEXs. Traders can view detailed charts for each pair, consult a transparent order book to see liquidity on both sides, and place either market or limit orders. As a reminder, limit orders allow you to buy or sell at exact target prices. - -This is basically all the relevant options you have for spot trading on Starknet. But what if you want leverage? Starknet now has two strong Perp DEXs live: one built natively on Starknet, and another operating as a Starknet appchain. - -### **2. Perp trading** - -When it comes to Perps, Starknet now has a truly **ultra-efficient Perp DEX** built directly on its chain (not as an appchain) by former Revolut executives: **Extended**. - -On Extended, you can trade with leverage across a wide range of markets: - -- Up to **50x** on ~50 crypto pairs -- Up to **100x** on traditional markets such as **EUR/USD, Gold, Oil and the S&P 500** - -But Extended isn’t only for traders. You can also become a liquidity provider by depositing into its vault, which currently yields over **25% APR in USDC**. Returns come from a mix of team-driven market making, trading fees, and liquidations. - -Note that Extended is running an **incentive campaign** where you can earn points by trading, providing liquidity, or referring new users. Just saying. - -Extended isn’t the only Perp DEX on the Starknet ecosystem. **Paradex**, built as a separate appchain closely connected to Starknet, offers similar features to Extended but without TradFi markets. - -Since this guide focuses on the **public Starknet chain only**, I won’t go into detail here. If you’d like to learn more, you can check out my full deep dive on Paradex - -Trading is great, but if yield farming is more your thing, Starknet also offers plenty of ways to put your assets to work. - -### **3. Yield farming** - -In addition to Extended’s vault, Starknet offers plenty of options for yield hunters. Whether you prefer lending, LPing, or liquid staking, there’s a growing ecosystem to put your assets to work. - -#### **Vesu (Lending & Borrowing)** - -Vesu is Starknet’s leading money market. Users can lend assets to earn yield or borrow against them. Lenders earn from two sources: - -1. Interest paid by borrowers -2. Incentives from the Starknet Foundation’s **DeFi Spring** program - -What makes Vesu attractive is its simplicity: - -- Earn passive yield by lending your assets -- Borrow additional assets to fuel your DeFi strategies - -A standout feature offered by Vesu is **Multiply**, which lets you create advanced looping strategies in a single click (though it also increases liquidation risk). - -**Example strategy I use:** - -- Lend ETH -- Borrow USDC at <2% -- Deploy USDC into Paradex’s vault (~25% yield) and Extended’s vault (~30% yield) - -Alpha: right now you’re essentially being paid to use your assets as collateral and borrow stablecoins. Just saying again 😉 - -#### **Nostra Finance (Lending, Borrowing & AMM Pools)** - -Another money market on Starknet is Nostra Finance. Like Vesu, it allows lending and borrowing, but currently Vesu offers better rates and more innovative features. Still, Nostra is worth watching for rate differences and opportunities. - -Beyond lending & borrowing, Nostra also offers **AMM pools**, where LPs can earn from both swap fees and DeFi Spring incentives. - -#### **FixedLend (Lending & Borrowing)** - -FixedLend is a smaller protocol, but with a powerful feature: an **Order Book of Yield.** - -- Lenders set both the **rate** and the **duration** of loans -- Borrowers choose whether to accept -- Once matched, loans are locked with a **fixed rate** and **defined maturity** - -This solves a key issue in classic money markets: variable rates that force constant monitoring. - -#### **Ekubo (AMM)** - -Beyond lending, Starknet has Ekubo, arguably the most efficient AMM in crypto. Thanks to ultra concentrated liquidity, gas-optimized execution, and its singleton design, every dollar of liquidity works harder: - -- Tighter spreads -- Lower slippage -- Higher fee capture - -For LPs, this means unmatched capital efficiency: earn more fees with less capital at risk. Proof? With only ~$20m TVL, Ekubo is already a top 2 DEX by volume on Ethereum. - -Ekubo also supports spot trading with swaps, DCA, and limit orders. - -If you want to dive deep into Ekubo, here is the most complete article to date about it - -#### **Troves (Automated Yield Optimizer)** - -Troves lets you deploy capital into advanced strategies with a single click. Examples include: - -- Lending on Vesu while auto-rebalancing to the best rates -- Weekly auto-claim and compounding of DeFi Spring rewards -- Looping strategies (lend → borrow → re-lend → repeat) -- Managing LP positions on Ekubo to maximize yield - -Troves handles it all automatically, meaning you can access these strategies and benefit from them passively with a single click. - -#### **Opus (Starknet Native Stablecoin)** - -Opus is the protocol behind Starknet’s only native stablecoin: **CASH**. You can mint CASH by depositing 7 types of collateral: ETH, STRK, wBTC, xSTRK, wstETH, Ekubo, and LORDS. - -CASH is particularly attractive because you can **stack three yield sources at once** with this stablecoin: - -1. Provide liquidity in the CASH/USDC pool on Ekubo -2. Stake the LP NFT on Opus to receive 75% of protocol revenue -3. Earn additional yield from U.S. Treasury exposure (T-bills) - -As of August 2025, the APY is ~**18%**. - -#### **Endur (Liquid STRK & BTC staking)** - -Endur currently offers **liquid STRK staking.** You stake STRK to secure the Starknet’s network, earn rewards (~6.5% APR), and receive a liquid token (xSTRK) you can use across DeFi. Example strategy: - -- Stake STRK on Endur (~6.5% APR) -- Lend xSTRK on Vesu (~3% APR) -- Borrow USDC against it -- Deploy USDC into Extended or Paradex vaults for high yield (~25%) - -This dual benefit makes Endur a cornerstone of Starknet’s DeFi stack. - -Soon, Endur will also support liquid BTC staking once Bitcoin staking goes live on Starknet (expected in the coming weeks). - -### **4. Other DeFi Primitives on Starknet** - -Starknet’s DeFi stack doesn’t stop at lending, DEXs, and staking. A growing set of other DeFi primitives are live, covering savings, payments, prediction markets, options, and token launches. - -#### **Bountive (No-Loss Prize Savings)** - -Bountive introduces a **no-loss savings mechanism** that turns yield farming into a lottery-style game. - -How it works: - -- Users deposit assets into a pool -- Funds are deployed into DeFi strategies by Bountive -- Yield is used to fund **lottery prizes**, distributed among winners -- Deposits remain withdrawable at any time - -This model blends **savings + gamification**, replacing fixed APR with the chance to win **much bigger rewards**. - -#### **Raize Club (Prediction Markets)** - -Prediction markets have historically been one of the few DeFi primitives with real traction, and Starknet has its own: **Raize Club**. - -- Bet on outcomes ranging from crypto prices to real-world events -- Place a bet in one click -- Choose from **four different tokens to place your bets** (not just USDC, unlike most prediction markets) - -The mix of simplicity and flexibility makes Raize Club stand out. - -### **Payments on Starknet** - -When it comes to payments, three main products are currently live on Starknet. - -The first is **Pulsar Money**, which makes crypto payments as simple as sending a tweet. - -Integrated directly with **X (Twitter)**, Pulsar enables frictionless transfers between users. It’s perfect for tipping your favorite creators or boosting the reach of your posts by attaching a prize pool for those who engage. - -The second is the **Ready Card**, a crypto debit card by Ready, Starknet’s native wallet. You can pay anywhere Mastercard is accepted using your onchain USDC, with no FX fees, and even earn up to **10% cashback** on daily spending. It’s the perfect bridge between your onchain assets and real life. - -Finally, there’s **Braavos**, the second Starknet’s native wallet, which integrates the **Bitcoin Lightning Network**. - -This lets you use Lightning payment terminals directly from Starknet. In practice, you just open your Braavos mobile wallet and scan a QR code to pay instantly anywhere Lightning is accepted. - -#### **Carmine Options (European-style options)** - -**Carmine Options** is the first options protocol live on Starknet, bringing **European-style options** fully onchain. - -For context: **European options** are financial contracts that give you the right, but not the obligation, to buy (call) or sell (put) an asset at a set price, but only on the option’s expiry date. - -Carmine makes this powerful primitive accessible on Starknet, enabling users to: - -- Speculate on price moves with limited downside risk -- Protect against sharp drops in asset prices -- Hedge impermanent loss for LP positions -- Provide liquidity to earn fees on options markets - -Currently, Carmine supports calls and puts on **ETH, STRK, wBTC, and Ekubo.** - -#### **Unruggable (Token Launchpad)** - -**Unruggable is Starknet’s native token launchpad, built to make memecoin launches safer and fairer.** - -For **creators**, it offers a **no-code interface**, so anyone can launch a memecoin in just a few seconds, with no technical skills required. - -For **traders**, every launch comes with built-in protections: - -- Liquidity locked for at least **6 months** (or forever if none is added) -- Team allocation capped at **10%** (max 5% per member) -- **Anti-whale rules** in the first 24 hours to ensure fairer distribution - -Tokens certified as **“Unruggable”** can be verified directly on the official site or through platforms like AVNU, where a badge confirms the certification. - ---- - -## **Onchain Gaming on Starknet** - -Starknet hosts the most advanced **fully onchain gaming ecosystem** in crypto. Unlike the “Web2.5” experiences other chains brand as onchain gaming, most Starknet titles run entirely onchain: every mechanic, every asset, every interaction. - -Why does this matter? Because being fully onchain means true **ownership** of everything you create or earn, and games that cannot simply vanish. We’ve already seen the opposite with _Pirate Nation_ on Arbitrum, which shut down its instances; something impossible when a game is entirely onchain. - -#### **Realms (Age of Empires Onchain)** - -The flagship game on Starknet is **Realms** (formerly Eternum). It captures the spirit of Age of Empires, Civilization, and Travian, but fully onchain. - -Realms is a grand strategy game where you expand your realm, manage resources, trade, form alliances, betray, and wage wars for dominance. - -In recent months, Realms has rolled out major improvements, not only in design and gameplay, but also in accessibility: players can now log in via the **Cartridge Controller** using Discord or Gmail accounts, and even connect with EVM wallets. - -The team has also introduced two distinct modes: - -- **Eternum** → the full, long-form version, where matches last several weeks. -- **Blitz** → a fast-paced mode designed for quick 2-hour sessions. - -The first Eternum seasons launched in the past months, and new seasons are coming soon, this time featuring the brand-new Blitz mode. - -#### **BlobArena (Pokémon-Inspired Battles)** - -**BlobArena** is a playful, onchain reinterpretation of Pokémon, focused entirely on **fighting**. Players control Blobs in fast-paced duels, with every move executed onchain. - -A recent partnership with **AMMA (Armored Mixed Martial Arts)** brought BlobArena into the real world, distributed and showcased at AMMA’s live events. This makes it the first fully onchain game with real-world competitive integration. Powered by Starknet. - -#### **Art Peace (r/Place Onchain)** - -One of the most creative experiments on Starknet is **Art Peace**, a **shared onchain canvas** built by StarkWare and inspired by Reddit’s iconic _r/Place_. Just like on Reddit, anyone can place pixels on the canvas, but here, every action is recorded fully onchain. - -The concept transforms creativity into gameplay: users collaborate (or compete) to design mosaics, leave messages, or build collective masterpieces. Beyond being a playground for creativity, **Art Peace has become a tool for community engagement**. Projects and DAOs regularly use the canvas to launch mini-competitions with prize pools lasting several days. - -Follow the project closely, you might win something, and you’ll definitely have fun. - -#### **PonziLand (token-agnostic DeFi metagame)** - -The concept behind PonziLand is simple, and very degen: you **buy land** on the PonziLand grid, set a resale price in any token (STRK, PAPER, LORDS…), and the game begins. - -Each day, you pay a **small tax** (based on your land’s price) to your **neighbors**. You pay in your token but receive taxes in theirs. If their tokens pump harder, you profit; if not, you get rugged. It’s a constant battle of **strategy, speculation, and neighbor wars**. Conquer plots, optimize your exposure, and climb the map to become a true **PonziLord**. - -The game runs in **seasons**, so you’ll need to wait for the next one to begin (coming soon 👀). - -#### **Jokers of Neon (Poker strategy)** - -Jokers of Neon is THE game for poker lovers. - -In this game, you start with a deck of cards, and each round you have a limited number of plays to score as many points as possible. Points come from forming classic poker hands (pairs, straights, flushes, full houses…), and stacking them with in-game combos and bonus multipliers. - -The strategy lies in choosing whether to play the cards in your hand or discard them to draw new ones, chasing that perfect combination before you run out of moves. - -And of course, every single move happens fully onchain. - -#### **Force Prime Heroes (Heroes of Might and Magic Onchain)** - -Force Prime Heroes is a strategy game where you explore the map with your hero, gather resources, recruit units, and grow your army to ultimately defeat the **Bone Dragon** or other bosses. Each move consumes movement points (structured in days and weeks), income flows from captured buildings, and your final score depends on both **efficiency and speed**. - -Victory requires balancing hero progression, smart recruiting, and efficient map control. - -Oh, and you can even **design your own maps** here: Force Prime Editor - -#### **Pistols at Dawn (Cowboy Duels Onchain)** - -Pistols at Dawn is a 1v1 showdown where you face another Lord in a classic Western-style pistol duel to defend your honor. The rules are simple: challenge a friend or any opponent, and step into a high-stakes standoff. - -Every shot, every victory, every defeat is recorded fully **onchain.** - -#### **Dark Shuffle (Roguelike Deck-Builder)** - -Dark Shuffle is a fully onchain card-based strategy game. - -At the start of each run, you draft 20 cards to define your initial strategy. From there, you dive into **randomly generated maps** filled with branching paths. Every choice, which path to take, which card to play, or which battle to risk, shapes your journey and determines how far you can go. - -#### **Dope Wars (Hustle & Empire Building)** - -Dope Wars is a fully onchain strategy and role-playing game. - -Players start as hustlers in a gritty world, with one simple goal: **buy low, sell high, build your empire, and outsmart your rivals.** - -#### **zKube (Onchain Puzzle Challenge)** - -zKube is a fully onchain **puzzle game**, blending **Tetris** with sliding-block mechanics. You manipulate patterned blocks on a grid to solve challenges step by step, blockchain logic makes every move verifiable. - -#### **ByteBeasts (Tamagotchi)** - -ByteBeasts is **Tamagotchi reborn**, fully onchain on Starknet. Mint your digital pet, feed it, nurture it, bond and play with it. - -#### **Evolute (Carcassonne Meets Mage Duels)** - -Two sorcerers face off on an 8×8 grid, shaping Cities, Roads, and Fields with each tile they place. Tiles must connect logically, and control is gained by completing constructions, but territory can always be contested. Points from Cities and Roads decide which mage emerges victorious. - -Evolute is onchain, but settling on Celestia. - ---- - -## **Best tools on Starknet** - -DeFi and gaming are cool, but you need solid tooling to really get the most out of Starknet. Here’s the list of the most important ones. - -#### **Ready Portfolio (Portfolio tracker)** - -Beyond its role as one of Starknet’s native wallets, Ready also offers a **portfolio dashboard**. It allows you to track your (or someone else 👀) assets, positions, and DeFi allocations across the network in a simple and intuitive interface. - -#### **AVNU Market** - -AVNU launched a **DEXscreener-like platform**: AVNU Market. It lists all available markets on Starknet and offers a wide range of analytics for each asset, price charts, liquidity depth, trading volumes, and more. - -A must-have for traders tracking tokens in real time on Starknet, and a great complement to Dexscreener and GeckoTerminal. - -#### **StarkPulse** - -StarkPulse is a **Telegram bot** designed to monitor Starknet’s onchain activity. It lets you: - -- Track specific wallets and receive instant alerts when they buy or sell assets. -- Get notified when a new token is created on Starknet. - -In practice, StarkPulse puts the onchain trenches directly in your Telegram feed. It’s still relatively unknown on Starknet, so here’s the alpha. - -#### **Cartridge Arcade** - -Imagine having one single interface that brings together most of the games on Starknet, with a point system and a leaderboard to compete against all other Starknet gamers. - -That’s exactly what Cartridge Arcade offers. It showcases all the games built on the Cartridge/Dojo ecosystem (which powers most of Starknet’s gaming scene), lets you jump in, play easily, and track your progress compared to other players. - -Think of it as Steam for Starknet gaming. - -#### **Voyager** - -Voyager is one of the first and most widely used **block explorers** on Starknet. Similar to Etherscan on Ethereum, it provides transparency into every transaction, contract, and wallet on the network. It also offers high-level insights into Starknet’s activity in real time. - -#### **Starkscan** - -Starkscan is another major block explorer on Starknet, providing a different UI/UX. - -#### **Focus Tree** - -Focus Tree is a productivity app designed to help you win back your attention. It lets you: - -- Set focus timers - -- Block distractions on your phone - -- Earn items by completing sessions - -- Build your digital garden - -In practice, Focus Tree turns deep work into a game, making discipline visible, distractions costly, and progress rewarding. - ---- - -## **Bonus: How to Contribute to Starknet with the Wolf Pack League** - -The **Wolf Pack League (WPL)** is StarkWare’s flagship community program, created to accelerate Starknet’s growth. The vision is simple: just like wolves are stronger together when they hunt in packs, Starknet thrives when its community of builders, creators, and contributors moves forward as one. **To turn this vision into reality, the WPL connects projects and contributors through two complementary programs:** the WPL Platform and WPL Attested Creators. - -#### **a. WPL Platform** - -The WPL Platform is **open to everyone**. It acts as a **marketplace of collaboration** where projects and community members meet: - -- **Projects** can create missions (specific bounties/tasks) and open them to the whole Starknet community. -- **Contributors** can browse these missions, pick the ones that fit their skills (content, design, development, research, etc.), and submit their proposals. -- **Rewards** are then distributed by the projects to the winning submissions, ensuring fair recognition and value exchange. - -This system gives projects a way to boost their visibility and growth while empowering contributors with opportunities to showcase their talent, earn rewards, and become more deeply involved in Starknet. - -#### **b. WPL Attested Creators** - -The second pillar of the WPL highlights long-term contributors: the **Attested Creators**. These are individuals who have been consistently pushing Starknet forward with **high-quality content and meaningful contributions**. - -- The more they contribute, the more they **grow in reputation** within the program. -- In addition to the rewards available on the open WPL platform, attested creators receive **extra recognition and benefits** for their sustained impact. - -In other words, **Attested Creators are the pack leaders,** trusted voices who inspire others while being rewarded for their consistency and dedication. And if you keep contributing, you might soon join them. - -Starknet is the best place to start contributing and gain recognition for it. And the right time to start is now. - ---- - -## **Conclusion** - -The foundations of Starknet are stronger than ever, with all the core primitives now in place to build increasingly advanced use cases on top. Yet it’s still **day one** for the ecosystem: there’s plenty of room for anyone to make their mark, and programs like the **Wolf Pack League** make it easier than ever to get involved. - -But don’t wait too long: momentum is accelerating, with **Starktember now live and BTCfi only a few weeks away. The best time to join is NOW.** - -In the meantime, make sure to follow the full Starknet crew to stay up to date with everything happening across the ecosystem. **See you on the other side.** - -This article was also publishes on Lyskey’s blog. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-incident-report-september-2-2025/ - ---- - -## Starknet Incident Report — September 2, 2025 | Starknet - -Home  /  Blog - -Sep 11, 2025 · 4 min read - -On September 2, 2025, shortly after upgrading to version 0.14.0 (Grinta), Starknet experienced an outage during which block production was halted and two chain reorganizations (reorgs) were required to restore normal operation. - -We recognize the impact this had on our users and partners, and we are committed to providing full transparency into what happened, how it was resolved, and what steps we are taking to prevent recurrence. - -This incident occurred in the immediate aftermath of a historic milestone: **Starknet became the first Validity (ZK) rollup to decentralize its sequencer architecture, moving from one to three sequencers operating the network.** That shift was the core change that exposed this new challenge – one that is inherent in pioneering the path toward decentralization, a path that only Starknet has taken so far. - -Since the incident ended on September 2 at 13:41 UTC, Starknet has been fully operational. We are continuing to push the boundaries of proving and advancing toward becoming the first decentralized Validity (ZK) Rollup, while also applying the key insights from this incident to further strengthen Starknet’s resilience going forward. - -## **Summary** - -Between **02:20 and 13:40 UTC**, Starknet was intermittently unavailable. During that time, two reorgs were required: - -- The first reverted roughly **one hour of transactions**. -- The second reverted roughly **20 minutes of transactions**. - -The downtime was caused by a sequence of three interconnected incidents, beginning with a failure in Ethereum RPC providers at the node logic level. - -A deeper investigation identified the following contributing factors: - -**1. Ethereum node failures** – The three Starknet sequencers, which operate as part of its decentralized architecture, observed different states of Ethereum. This divergence disrupted the block-proposing process: one sequencer proposed transactions triggered by Ethereum messages that the others could not validate. As a result, network progression slowed significantly. - -**2. Manual intervention gap** – To address the sequencer failures discussed above, a manual intervention was required. In this manual process, certain validations that are performed automatically were skipped, which resulted in the creation of two conflicting blocks in the L2 layer by the different Starknet sequencers. To restore correctness, a reorg was performed. - -**3. Blockifier bug in v0.14.0 –** After the first reorg, transactions were discarded but L1→L2 messages were reprocessed. Some of these messages assumed that earlier Starknet transactions had already been executed, and when that assumption failed, they reverted. This triggered a bug in the blockifier – the component responsible for updating Starknet’s state based on transaction execution. The bug affected how reverted transactions initiated by L1→L2 messages were handled. This compounded the earlier disruptions and required both a hotfix and a second reorg to fully resolve. - -When analyzing the failures, we identified issues in the **consensus mechanism** and **blockifier logic**, which will be detailed further below. - -It is important to note that throughout the incident, **Starknet’s proving layer acted as the safeguard** that prevented these inconsistencies from compromising the integrity of the blockchain. This design reflects a core principle of Starknet: to preserve correctness and security regardless of any undesired sequencer behavior-whether caused by software bugs or by malicious activity. - -## **Impact** - -- **Downtime**: Approximately 9 hours of degraded or halted service. -- **Reorgs**: All transactions in the affected blocks reflecting ~1.5 hours of activity were not processed and needed to be resubmitted. - -## **Timeline** - -At **02:20 UTC**, initial issues were detected when sequencers failed to sync L1 events, preventing new blocks from being approved. An investigation was initiated immediately. By **03:57**, after several manual attempts to reset individual sequencers, L1 synchronization succeeded and Starknet resumed. - -At **04:10 UTC**, an alert indicated that the proving layer had detected an inconsistency, marking the beginning of the second incident. Apparently, different sequencers were building blocks on top of different versions of a certain block, and this was a result of our previous manual intervention. Starknet, as a validity rollup, first sequences blocks, and later proves them. When the proving layer detects an inconsistency (or any other invalid logic), it cannot generate a valid proof. By **04:37 UTC**, Starknet was manually halted, since it became clear that a reorg might be required in order to fix this issue. This approach is based on the principle that when a reorg is anticipated, halting the system helps to minimize potential transaction loss. - -At **06:05**, we identified the block where the inconsistency occurred, and thus decided to re-org back to the block before (1,960,612), , reverting approximately one hour of activity. Block production resumed at **07:42** and by **09:08** all full node clients were synced and Starknet operations were fully restored. - -The third incident began at **10:28**, when the proving layer identified another inconsistent batch. At **10:43**, Starknet was halted again as the probability for a second reorg became high. By **12:05**, the root cause was identified, and at **12:37** a bug fix was implemented, tested and deployed. At **13:29**, a second reorg was executed from block **1,962,681**, reverting roughly 20 minutes of activity. Finally, at **13:41**, block production and full network activity were restored. - -## **Key learnings and Prevention Measures** - -In addition to detecting, analyzing, and rapidly fixing the bugs that caused this failure, and adding safeguards that will automatically prevent such failures from recurring, we are also implementing a set of measures designed to further reduce the likelihood of similar issues in the future: - -- **Increase the number of nodes** participating in the internal consensus protocol to improve fault tolerance and resilience. -- **Introduce additional safety mechanisms** to protect against disruptions when external dependencies, such as Ethereum nodes, experience issues. -- **Minimize the need for manual interventions** and ensure that in the rare cases they are required, the process is reliable, well-documented, and resistant to human error. - -## **Closing** - -Starknet is back online and fully operational. While the incident was serious, the fixes applied have already increased network resilience, and additional long-term improvements and safeguards are being implemented. - -By identifying and addressing these bugs immediately upon detection, and with the proving layer serving as a backstop, Starknet emerges more robust. The fixes applied in response, together with additional safety precautions now being implemented, directly strengthen its reliability going forward. It is also worth noting that the Starknet dapp teams were well-prepared to handle reorgs, which ensured users were minimally affected at the application level throughout the incident. - -We are committed to full transparency with our users and partners, and will continue to share follow-up updates as improvements are rolled out. - -**Thank you, Starknet community, for your understanding and support as we worked through this issue.** - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Global Payments, Settled Fast on Starknet – Powered by Due - - Due offers cheap, fast global payments with low fees, virtual bank accounts, and instant USDC settlements through Starknet. - - September 4, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/why-bitcoin-staking-is-a-big-deal/ - ---- - -## Starknet Launches Bitcoin Staking - -Home  /  Blog - -Starknet now supports Bitcoin staking. It's a simple headline, but it has profound implications. - -Sep 30, 2025 · 4 min read - -Some 98.5% of Bitcoin sits idle on the Bitcoin network. This represents USD$ 2 trillion worth of value that is unutilized and locked away. It is no surprise then that an increasing number of projects are trying to unlock this value. In the world of DeFi, for example, Bitcoin value could drive deeper liquidity, more efficient markets and serve to unlock entire ecosystems and use cases. - -Value is equally important in the world of decentralization and distributed consensus. For Proof-of-Stake networks, like Ethereum and Starknet, the security of the network is directly correlated to the value staked. Enabling Bitcoin to stake and secure Starknet is a major milestone for both Starknet and Bitcoin. - -## How Starknet Immediately Benefits - -Starknet’s Bitcoin staking will immediately increase the value of the assets that are staked to secure Starknet. Today, there are 65,000+ delegators and 550 million+ STRK staked. The launch of Bitcoin staking will increase this number and thereby enhance the security characteristics of Starknet. Simply on those merits, Bitcoin staking is a significant development. - -Remember, Bitcoin is generally regarded as lower risk and a very attractive relative to other cryptocurrencies. As a result, Bitcoin holders require lower rewards than other cryptocurrencies to participate in similar programs. This means that in the long-term, Bitcoin staking is cheaper than STRK staking for an equivalent level of cryptoeconomic security. - -Starknet is uniquely positioned to rollout a successful Bitcoin staking protocol. Most networks, especially L2s, do not have a sufficiently adopted and decentralized staking program for their native token. If a network ends up with only Bitcoin stakers, it dilutes the role of its native token and its governance processes. The large adoption of STRK staking on Starknet enables the rollout of a successful Bitcoin staking program. The governance proposal that was approved is very detailed on how STRK and Bitcoin support each other. The consensus power of staked Bitcoin is limited to 25% of the network. STRK will hold the remaining consensus power, ensuring STRK staking maintains its centrality in securing starknet. - -## The Bitcoin Flywheel - -**But it gets better**: Bitcoin staking on Starknet kicks off a significant flywheel for the entire Starknet ecosystem. Here’s how: - -Bitcoin staking on Starknet will bring significant amounts of Bitcoin to the Starknet ecosystem, sustainably and perpetually. This will enhance the security characteristics of the network and the liquid TVL on Starknet. Enhanced security and increased liquidity in turn will attract more builders and assets to the entire Starknet ecosystem, further increasing the amount of STRK staked. By the mechanism designed and approved for Bitcoin staking, this increase in STRK staking will result in an increase in the rewards distributed to Bitcoin stakers, further incentivizing Bitcoiners to stake their Bitcoin, starting what is a powerful, reinforcing flywheel on Starknet. - -Let’s break down these components into more detail: - -Starknet’s Proof-of-Stake, like all PoS systems, rewards participants for securing the network by giving them newly created tokens, in this case STRK. These emissions are a naturally occurring part of PoS networks (and PoW networks too). They do not require special incentives. They are not one time programs. They do not depend on activity farming or other short-term behaviours. These rewards are part of a long-term, sustainable program. - -As already discussed, the more assets that are staked on a network, the more secure the network is. Enhanced security drives adoption. More Bitcoin staked also drives adoption in another meaningful way: liquid-staked tokens. Bitcoin stakers have the possibility to participate in liquid-staking programs, where they receive a derivative token representing their staked positions. Just like on other PoS networks, these liquid stake tokens themselves can be used to drive usage in DeFi. - -This in turn boosts STRK’s utility, as it is Starknet’s core asset: - -- Default token for gas and staking -- Governance token -- Main DeFi collateral -- Next up: a fee-burn (ETA TBD) aimed at reducing supply as usage scales. - -The amount of STRK staked is what determines emissions for both STRK staking and Bitcoin staking. This was implemented to make sure that STRK maintains its dominant position in securing Starknet. The mechanism for determining emissions increases emissions for both STRK and Bitcoin when more STRK is staked. This positive relationship is critical for securing Starknet with both BTC and STRK. - -## Why Should Bitcoiners Care? - -Bitcoin Staking (and the broader BTCFi rollout) is another step on Starknet’s journey of decentralization, innovation and security. - -Earlier this year, Starknet announced it became a Bitcoin and Ethereum L2. Starknet wants to leverage the security of both layers, and use its STARK-based zk-L2 to provide scale, security and low-cost transactions to both Ethereum and Bitcoin, without sacrificing decentralization. Last month, Starknet’s Grinta upgrade was yet another big step. Starkware has also released significant research and software on Bitcoin and zero-knowledge cryptography, including research on ColiderVM, providing a toy implementation of ColiderVM, setting up a $1m research fund on OP_CAT and setting a world record for proving Bitcoin mainnet with ZK proofs. And the roadmap is accelerating. - -Bitcoin staking presents an opportunity for Bitcoin holders to support a leading project promoting decentralization, cryptography, privacy and security, while also earning sustainable rewards. - -For the first time, Bitcoin holders can stake their Bitcoin to secure a Layer 2 and earn sustainable rewards. - -To learn how to stake your tokens, see the Bitcoin User Guide here. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - -- #### Global Payments, Settled Fast on Starknet – Powered by Due - - Due offers cheap, fast global payments with low fees, virtual bank accounts, and instant USDC settlements through Starknet. - - September 4, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/introducing-the-re7-yield-aggregator-on-starknet/ - ---- - -## Re7 Labs Yield Aggregator Live on Starknet - -Home  /  Blog - -Sep 25, 2025 · 2 min read - -We are excited to share that the \***\*Re7 ALMM by Re7 Labs is now available** on Starknet\*\*. This new product is designed to make yield generation simple, sustainable, and accessible to anyone interested in DeFi. - -## **What Is the Re7 **ALMM**?** - -The Re7 ALMM is the Automated Liquidity Market Maker, built specifically for **Ekubo liquidity pools on Starknet**. It continuously monitors APRs and market activity and automatically rebalances LP positions. The result: your assets are always working. - -Instead of having to check and rebalance constantly, you simply deposit your assets once. From there, the ALMM does the work in the background, keeping your capital efficient. - -## **Turning DeFi Challenges into Opportunities** - -Starknet is rapidly becoming a leading destination for scalable DeFi. With this growth comes new opportunities, but also new challenges for users. One of the biggest pain points is managing liquidity positions effectively. - -Traditionally, this requires building complex strategies, keeping up with APR changes, and constantly adjusting positions. For many, that barrier is too high. Re7 set out to solve this problem: to give users the benefits of advanced yield strategies, without the complexity that usually comes with them. - -## **The How** - -Managing liquidity is often time-consuming, and even experienced users can struggle to capture optimal yield consistently. Re7 makes the process more straightforward: - -- - No strategy building required. - -- - No ongoing monitoring needed. - -- - Just deposit and earn. - -Vaults are built on top of Trove’s audited and tested on-chain infrastructure, combined with Re7 Labs’ proprietary rebalancing strategy. - -## **Re7 in Action: Features That Matter** - -The Re7 ALMM is designed with simplicity and performance in mind: - -- - **Focused on Ekubo liquidity pools** – ensures access to the highest APRs. - -- - **Active rebalancing in real time** – yield stays more optimized without relying on short-term incentives. - -- - **User-friendly experience** – deposit-and-earn model that requires no special knowledge. - -- - **Fully automated strategies** – no manual adjustments needed once you’ve deposited. - -## **Strengthening the Ecosystem** - -This launch is part of a broader effort to establish Starknet as the most capital-efficient DeFi ecosystem. By making sophisticated yield strategies accessible to everyday users, we are not only lowering barriers but also contributing to stronger liquidity and activity across the network. - -## **About Re7** - -Re7 Labs – a DeFi centric investment firm specialising in DeFi yield, liquid alpha strategies and on-chain vault management. With over 4 years of a consistent positive track record, Re7 is one of the most active DeFi liquidity providers globally, currently overseeing ~$1b. Re7 Labs is the innovation arm of Re7 Capital, focused on on-chain risk curation, vault management, and DeFi ecosystem design. Launched just over a year ago, it currently curates over $800 million in DeFi vaults across leading protocols. - -## **What’s Next** - -The **Re7 Labs | **ALMM** on Starknet** is now available – starknet.re7labs.xyz. - -Terms and Conditions apply, please review before engaging. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Starknet Foundation Introduces: BTCFi Season - - The Starknet Foundation launches BTCFi Season with 100M STRK to fuel BTC DeFi, stablecoin borrowing, and ecosystem growth. - - October 1, 2025 - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - ---- - -Sources: - -- https://www.starknet.io/blog/starknet-foundation-introduces-btcfi-season/ - ---- - -## BTCFi Season: 100M STRK Incentives on Starknet - -Home  /  Blog - -Oct 1, 2025 · 3 min read - -## Useful Resources - -- BTCFi Season’s official website -- BTCFi on Starknet - -## Introduction - -The Starknet Foundation is committed to Starknet’s emergence as the leading destination for sustainable yield on BTC. After months of careful research, planning, and design, the Starknet Foundation is proud to announce the launch of BTCFi Season, a program designed to set a BTC-centric DeFi flywheel in motion that will unlock productive capital flows on Starknet and ensure its long-term ecosystem growth. - -In Starknet’s case, lending and borrowing will be the cornerstone of the DeFi flywheel. That’s why enabling borrowing sits at the heart of BTCFi Season’s design, positioning Starknet to become the cheapest place to borrow stablecoins against BTC collateral. - -BTCFi Season is part of the broader BTCFi initiative on Starknet, which focuses on making BTC productive in DeFi with a strong emphasis on sustainability while upholding its core principles of security and decentralization. Other important Starknet launches under this initiative include Re7’s new BTC Yield Fund, BTC Staking, and StarkWare’s upcoming Earn – One-click Yield aggregator. - -## Program Details - -BTCFi Season was officially launched on **Tuesday, September 30th** by the Starknet Foundation. - -Participating protocols also launched their incentive programs on the same date. - -BTCFi Season is a structured incentive program supporting eligible ecosystem protocols that enable highly liquid BTC pools on DEXs and Money Markets and borrowing of stablecoins against BTC collateral. - -Starknet Foundation has dedicated a budget of 100M STRK to this program. - -The program is set to run for a minimum of six months, with the potential to continue well beyond that. - -## How the program works - -The Starknet Foundation has partnered with OpenBlock Labs to design a program for the fair and equitable allocation & distribution of STRK tokens to participating DeFi protocols. - -The program runs on a weekly cycle, with any significant changes taking effect at the start of a new cycle. - -### Allocations - -Protocol allocations are determined on a daily basis. The allocations are based on methodologies that factor in important protocol performance metrics. Methodologies are designed to be robust and resistant to manipulation while allowing for continuous adjustments if needed to stay aligned with the evolving needs and contributions of protocols within the ecosystem. - -### Distributions - -At the end of a cycle, daily protocol allocations of the last 7 days are aggregated and reviewed by OpenBlock Labs. Once finalized and communicated to all relevant parties, STRK allocations are distributed to the participating protocols by the Starknet Foundation. - -Each participating protocol to the program is responsible for designing, announcing and implementing their own incentive programs to reward their users with STRK. Each protocol may determine its own criteria for rewarding users, deciding both which users qualify and how rewards are allocated on eligible activity and assets/pairs. - -Each protocol will be responsible for its own distribution of STRK to its users. - -Users can begin claiming their allocations from participating protocols for the first cycle of the program starting Friday, October 10th. - -## What’s next? - -More eligible assets and pairs for BTCFi Season and more participating protocols. - -More ecosystem products that align with the vision of BTCFi on Starknet. Stay tuned for more! - -## FAQs - -## General - -- What is BTCFi Season? - - BTCFi Season is an incentive program launched by the Starknet Foundation to bootstrap BTC liquidity and stablecoin borrowing activity against BTC on Starknet. - -- What is BTCFi Season’s purpose? - - BTCFi Season is an important piece of the broader BTCFi on Starknet initiative that is designed to enable the activities that will kickstart a flywheel effect for sustainable BTC yield -consistent, predictable and competitive, driven by real economic activity- and ecosystem growth on Starknet. - -- Which DeFi verticals does BTCFi Season support? - - BTCFi Season supports the DEX and Money Market verticals. - -- What activity will BTCFi Season support? - - BTCFi Season supports protocols that enable highly liquid BTC pools on DEXs and Money Markets and borrowing of stablecoins against BTC collateral. - -- What assets and pairs will be eligible for incentives? - - You can find an updated list of eligible assets and pairs on BTCFi Season’s website. - -- When does BTCFi Season launch? - - BTCFi Season launched on September 30th, 2025. - -- How long will BTCFi Season last? - - The program is set to run for a minimum of six months, with the potential to continue well beyond that. - -## I am a User - -- How do I know if a project is a participating protocol in BTCFi Season and will be distributing STRK rewards? - - You can find an updated list of eligible protocols on BTCFi Season’s website. - -- How do I know what actions are eligible for STRK rewards? - - You will need to explore the individual participating protocols and their terms of use to see how you can earn STRK through their programs. - -- How can I claim my STRK from BTCFi Season? - - You will need to follow the guidelines provided from the individual participating protocols as they are responsible for their own distribution of STRK to their users based on their terms of use and announced programs. - -- What happens if I don’t claim my STRK from BTCFi Season? - - You will be able to claim your STRK within each participating protocol. Any unclaimed STRK at the end of BTCFi Season will be returned back to the Foundation. - -## I am a Protocol - -- How can I participate in BTCFi Season? - - The Starknet Foundation determines the appropriateness of participating protocols in its absolute discretion and is focused solely on protocols that support the DEX and Money Market verticals. If you are interested in participating in BTCFi Season, please apply using this [form] and we will be in touch shortly. - -- What criteria should I use for my incentive program? - - Each protocol shall determine its own criteria for rewarding users, deciding both which users qualify and how rewards are allocated on eligible activity and assets/pairs. - -- Am I required to make the criteria of my incentive program public? - - Yes. Announcing your incentive program’s criteria and terms of use is a mandatory requirement to participate in BTCFi Season. - -## About the Starknet Foundation - -The Starknet Foundation is a non-profit organisation who oversees the growth and development of Starknet – a fast, scalable, future-proof, fully-verifiable tech platform. The Foundation oversees a broad range of educational, grant, and startup programs and partnerships that support developers and founders solving real world problems. - -The Starknet Foundation has allocated a total of 100 million STRK for BTCFi Season. - -## About OpenBlock Labs - -OpenBlock Labs is a quantitative research firm specializing in organic and sustainable ecosystem growth by providing data analytics and modeling to ensure that the chain is growing with real users. - -OpenBlock Labs will lead the recommendations of STRK allocations, the implementation and the analytics of the program. - -## Important Disclaimers & Disclosures - -The following disclaimers and risk disclosures apply: - -- The DeFi protocols mentioned in this blog post are independent from the Starknet Foundation and are not owned, operated or controlled by the Starknet Foundation. -- Users who engage with DeFi protocols do so at their own risk and subject to the terms and conditions set forth by each respective DeFi protocol. The Starknet Foundation has no relationship with the individual users. -- The Starknet Foundation does not endorse or recommend any specific DeFi protocol. Users are encouraged to conduct their own research and to exercise caution before engaging with any such protocol. -- Users are solely responsible for their own decisions and actions and assume all risks associated with utilising the respective DeFi Protocols. -- Users should be aware that DeFi, as a category, involves inherent financial risks, including the potential for total loss of invested assets. -- The Starknet Foundation disclaims any and all liability for losses that users may incur through their use of DeFi protocols. -- Users and DeFi Protocols are responsible for complying with any applicable laws, regulations, or restrictions applying to them in either availing of or providing DeFi services (as the case may be). -- The information provided in this post is for informational purposes only and should not be construed as financial, investment or legal advice. Users should consult with a qualified financial advisor before making any investment decisions. -- The Starknet Foundation reserves the right to discontinue BTCFi Season at any time. -- This blog should not be considered an offer to the public or to any particular DeFi protocol. - -#### Join our newsletter - -Receive notifications on Starknet updates - ---- - -#### May also interest you - -- #### Why Bitcoin Staking is a Big Deal - - Bitcoin holders can now stake BTC on Starknet, boosting security, DeFi liquidity, and earning sustainable rewards. - - September 30, 2025 - -- #### Starknet x Bitcoin: The Next Step – BTCFi on Starknet - - Starknet brings trustless BTC staking, 100M STRK incentives, and new DeFi opportunities to scale Bitcoin. - - September 30, 2025 - -- #### Starknet Incident Report — September 2, 2025 - - On September 2, 2025, Starknet faced a 9-hour outage after upgrading to v0.14.0, requiring two reorgs to restore service. Learn what caused the incident,… - - September 11, 2025 - -- #### Global Payments, Settled Fast on Starknet – Powered by Due - - Due offers cheap, fast global payments with low fees, virtual bank accounts, and instant USDC settlements through Starknet. - - September 4, 2025 From 886d2ccee3009374266ecd98544abe981fb9be0f Mon Sep 17 00:00:00 2001 From: enitrat Date: Sun, 26 Oct 2025 08:24:24 +0100 Subject: [PATCH 2/4] better org of web target crawl --- .trunk/trunk.yaml | 4 + .../src/ingesters/StarknetBlogIngester.ts | 2 +- .../cairo_coder_tools/datasets/analysis.py | 1 - .../cairo_coder_tools/ingestion/crawler.py | 72 +++--- .../{blog_summary.md => starknet-blog.md} | 119 +++++----- .../ingestion/web_targets.py | 181 +++++++++++++++ python/src/scripts/README.md | 164 -------------- python/src/scripts/dataset.py | 2 +- python/src/scripts/ingest.py | 210 +++++------------- 9 files changed, 338 insertions(+), 417 deletions(-) rename python/src/cairo_coder_tools/ingestion/generated/{blog_summary.md => starknet-blog.md} (99%) create mode 100644 python/src/cairo_coder_tools/ingestion/web_targets.py delete mode 100644 python/src/scripts/README.md diff --git a/.trunk/trunk.yaml b/.trunk/trunk.yaml index 52eb15e9..9641a353 100644 --- a/.trunk/trunk.yaml +++ b/.trunk/trunk.yaml @@ -16,6 +16,10 @@ runtimes: - python@3.10.8 # This is the section where you manage your linters. (https://docs.trunk.io/check/configuration) lint: + ignore: + - linters: [ALL] + paths: + - python/src/cairo_coder_tools/ingestion/generated enabled: - ruff@0.12.3 - actionlint@1.7.7 diff --git a/ingesters/src/ingesters/StarknetBlogIngester.ts b/ingesters/src/ingesters/StarknetBlogIngester.ts index d2e9c88c..3c2dc7e6 100644 --- a/ingesters/src/ingesters/StarknetBlogIngester.ts +++ b/ingesters/src/ingesters/StarknetBlogIngester.ts @@ -50,7 +50,7 @@ export class StarknetBlogIngester extends MarkdownIngester { 'cairo_coder_tools', 'ingestion', 'generated', - 'blog_summary.md', + 'starknet-blog.md', ); logger.info(`Reading Starknet blog summary from ${summaryPath}`); diff --git a/python/src/cairo_coder_tools/datasets/analysis.py b/python/src/cairo_coder_tools/datasets/analysis.py index 6244af11..b9b320e9 100644 --- a/python/src/cairo_coder_tools/datasets/analysis.py +++ b/python/src/cairo_coder_tools/datasets/analysis.py @@ -5,7 +5,6 @@ import json from pathlib import Path -from typing import Any import dspy from dspy.adapters.baml_adapter import BAMLAdapter diff --git a/python/src/cairo_coder_tools/ingestion/crawler.py b/python/src/cairo_coder_tools/ingestion/crawler.py index 2899d71e..05e1ced6 100644 --- a/python/src/cairo_coder_tools/ingestion/crawler.py +++ b/python/src/cairo_coder_tools/ingestion/crawler.py @@ -9,7 +9,7 @@ from collections import deque from datetime import datetime, timezone from pathlib import Path -from typing import Callable, Optional +from typing import Optional from urllib.parse import urljoin, urlparse, urlunparse import aiohttp @@ -17,11 +17,13 @@ from markdownify import markdownify from tqdm.asyncio import tqdm +from cairo_coder_tools.ingestion.web_targets import IWebsiteTarget + # Configuration -UA = "NotebookLM-prep-crawler/1.1 (+contact: you@example.com)" +UA = "starknet-prep-crawler" OUT_FILE = Path("doc_dump") -CONCURRENCY = 4 # Low concurrency to avoid rate limits -MAX_RETRIES = 5 +CONCURRENCY = 4 +MAX_RETRIES = 6 TIMEOUT = 30 MAX_CRAWL_PAGES = 100 @@ -49,35 +51,24 @@ class DocsCrawler: - """Web crawler for documentation sites with filtering capabilities.""" - - def __init__( - self, - base_url: str, - include_patterns: Optional[list[str]] = None, - exclude_url_patterns: Optional[list[str]] = None, - content_filter: Optional[Callable[[str], bool]] = None, - content_processor: Optional[Callable[[str], str]] = None, - ): + """Web crawler for documentation sites with filtering capabilities. + + Uses an IWebsiteTarget object to define crawling behavior. + """ + + def __init__(self, target: "IWebsiteTarget"): """Initialize the crawler. Args: - base_url: Base URL to start crawling from - include_patterns: Optional list of regex patterns for URLs to include - exclude_url_patterns: Optional list of regex patterns for URLs to exclude - content_filter: Optional function that returns True if content should be kept - content_processor: Optional function to post-process content (e.g., remove sections) + target: IWebsiteTarget object defining crawling configuration and behavior """ - self.base_url = base_url.rstrip('/') + '/' + self.target = target + self.base_url = target.base_url.rstrip('/') + '/' self.domain = urlparse(self.base_url).netloc self.discovered_urls: list[str] = [] self.fetched_pages: dict[str, dict] = {} self.session: Optional[aiohttp.ClientSession] = None self.semaphore = asyncio.Semaphore(CONCURRENCY) - self.include_patterns = include_patterns or [] - self.exclude_url_patterns = exclude_url_patterns or [] - self.content_filter = content_filter - self.content_processor = content_processor async def __aenter__(self): timeout = aiohttp.ClientTimeout(total=TIMEOUT) @@ -115,7 +106,7 @@ def is_valid_url(self, url: str) -> bool: return not any(re.search(pattern, path, re.IGNORECASE) for pattern in EXCLUDE_PATTERNS) def filter_urls(self, urls: list[str]) -> list[str]: - """Filter URLs based on include/exclude patterns. + """Filter URLs based on include/exclude patterns from the target. This is applied AFTER discovery and BEFORE fetching. @@ -126,20 +117,18 @@ def filter_urls(self, urls: list[str]) -> list[str]: Filtered list of URLs """ filtered_urls = [] + include_patterns = self.target.get_include_url_patterns() + exclude_patterns = self.target.get_exclude_url_patterns() for url in urls: parsed = urlparse(url) path = parsed.path - # Check include patterns if provided - if self.include_patterns: - if not any(re.search(pattern, path, re.IGNORECASE) for pattern in self.include_patterns): - continue + if include_patterns and not any(re.search(pattern, path, re.IGNORECASE) for pattern in include_patterns): + continue - # Check custom exclude patterns (user-provided) - if self.exclude_url_patterns: - if any(re.search(pattern, path, re.IGNORECASE) for pattern in self.exclude_url_patterns): - continue + if exclude_patterns and any(re.search(pattern, path, re.IGNORECASE) for pattern in exclude_patterns): + continue filtered_urls.append(url) @@ -301,6 +290,7 @@ async def fetch_page(self, url: str) -> dict: logger.debug(f"Got {response.status} for {url}, retrying in {wait_time}s (attempt {attempt + 1}/{MAX_RETRIES})") await asyncio.sleep(wait_time) continue + logger.debug(f"Failed to fetch {url} after {MAX_RETRIES} attempts: {last_error}") # For other non-200 statuses, return immediately (no retry) return { @@ -429,14 +419,13 @@ def compile_markdown(self) -> str: if page_data.get('content'): title, markdown = self.extract_content(page_data['content'], url) - # Apply content filter if provided - if self.content_filter and not self.content_filter(markdown): + # Apply content filter from target + if not self.target.filter_content(markdown): filtered_out += 1 continue - # Apply content processor if provided (e.g., remove unwanted sections) - if self.content_processor: - markdown = self.content_processor(markdown) + # Apply content processor from target (e.g., remove unwanted sections) + markdown = self.target.process_content(markdown) if not markdown or len(markdown.strip()) < 50: markdown = "*No content extracted.*" @@ -458,7 +447,7 @@ def compile_markdown(self) -> str: error = page_data.get('error', 'Unknown error') logger.info(f"Skipping {url}: {error}") - logger.info(f"Filtered out {filtered_out} pages based on content filter: {self.content_filter}") + logger.info(f"Filtered out {filtered_out} pages based on content filter") return '\n'.join(lines) async def run(self, output_path: Optional[Path] = None) -> Path: @@ -510,10 +499,7 @@ async def run(self, output_path: Optional[Path] = None) -> Path: markdown_content = self.compile_markdown() # Save markdown - if output_path is None: - output_path = OUT_FILE.with_suffix('.md') - else: - output_path = Path(output_path) + output_path = OUT_FILE.with_suffix('.md') if output_path is None else Path(output_path) logger.info(f"Saving markdown to: {output_path}") output_path.write_text(markdown_content, encoding='utf-8') diff --git a/python/src/cairo_coder_tools/ingestion/generated/blog_summary.md b/python/src/cairo_coder_tools/ingestion/generated/starknet-blog.md similarity index 99% rename from python/src/cairo_coder_tools/ingestion/generated/blog_summary.md rename to python/src/cairo_coder_tools/ingestion/generated/starknet-blog.md index 934ce23b..493acca4 100644 --- a/python/src/cairo_coder_tools/ingestion/generated/blog_summary.md +++ b/python/src/cairo_coder_tools/ingestion/generated/starknet-blog.md @@ -1,4 +1,4 @@ -# www.starknet.io — Snapshot (2025-10-25) +# www.starknet.io — Snapshot (2025-10-26) --- @@ -614,6 +614,25 @@ In this conversation, Xverse CEO Ken Liao, team member Yan, and Francis from Sta Learn more about Starknet's Bitcoin vision → +--- +Sources: + - https://www.starknet.io/blog/starknet-on-bitcoin-and-ethereum/ +--- + +## Starknet on Bitcoin and Ethereum | Starknet + +Home  /  Blog + +Share this post: + +Mar 20, 2025 + +The recent STARK Spaces featured Abdelhamid Bakhta (StarkWare Head of Ecosystem), Avihu Levy (StarkWare CPO),  Eli Ben-Sasson (StarkWare CEO), Vitalik Buterin (Ethereum co-founder), Dan Robinson (Asymmetric general partner), and Jeremy Rubin (Bitcoin developer), discussing Starknet’s plan to bridge Bitcoin and Ethereum. Starknet aims to become the first Layer 2 solution to settle on both networks, leveraging its high throughput and zk-STARK technology to enhance scalability while maintaining decentralization and self-custody. + +The team emphasized that Bitcoin and Ethereum are the most credible decentralized networks, and integrating Starknet with both will unlock new use cases, like decentralized finance (DeFi) and privacy-enhancing payments, while preserving their core values. This move signals a new era of blockchain interoperability, making Starknet a key player in scaling both ecosystems without compromising on security or decentralization. + +Learn more about Starknet scaling both Bitcoin and Ethereum → + --- Sources: - https://www.starknet.io/blog/stark-spaces-the-diverse-flavors-of-the-sn-stack/ @@ -1819,7 +1838,7 @@ npm init -y # or yarn init -y yarn add starknet dotenv @avnu/gasless-sdk axios ``` -### +### ### **Step 3: Setting Up a .env File for API Keys** @@ -1970,7 +1989,7 @@ In this article, we’ll explore the need for on-chain games, their advantages, Games have been integral to human history, from ancient board games like Chess and Go to modern digital experiences like World of Warcraft and Fortnite. However, the underlying structure of games has remained largely centralized — players interact with a game world owned and controlled by a central entity (developers, publishers, or platforms). -### +### ### **The Transition to On-Chain Games** @@ -1981,7 +2000,7 @@ On-chain games introduce a revolutionary concept: games where both state and lo * The game state is public, auditable, and tamper-proof. * Games can be composable, allowing external developers to build on top of existing game worlds. -## +## ## **Why Do We Need On-Chain Games?** @@ -2161,7 +2180,7 @@ katana --disable-fee --allowed-origins "*" In another terminal window, navigate again to the contracts directory and build the contracts using Sozo, and apply the migrations to deploy the contracts: ``` -sozo build +sozo build sozo migrate apply ``` @@ -2356,7 +2375,7 @@ With Cartridge Controller, Web3 games can offer a frictionless experience, keepi --- -## +## ## **How to Integrate Cartridge Controller in Your Web3 Game** @@ -2493,7 +2512,7 @@ How Do Session Keys Work? 2. **dApp Executes Transactions**: The dApp uses this session key to sign transactions on behalf of the user within the given constraints. 3. **Session Expires**: After the session key expires (or reaches its limits), it can no longer sign transactions, ensuring security. -### +### ### Why are session keys useful? @@ -2969,7 +2988,7 @@ Builders were tasked with leveraging both Telegram and Starknet infrastructure t ### Special Challenges -The hackathon also featured sponsored challenges. Check out the winners for the other sponsored bounties here. +The hackathon also featured sponsored challenges. Check out the winners for the other sponsored bounties here. Onward to the ETHDenver Hacker House! The Starknet Winter Hackathon showcased the developer community’s creativity and skill. And with over 100 projects built, this is clearly just the beginning. @@ -3001,7 +3020,7 @@ Here’s everything you need to know (so far). ## Developer’s Journey: Building with Starknet -Starknet has always been committed to the founder’s product development journey, from ideation to mainnet launch and beyond. At our ETHDenver booth you can learn about all of the Starknet technology and opportunities that enable you to: +Starknet has always been committed to the founder’s product development journey, from ideation to mainnet launch and beyond. At our ETHDenver booth you can learn about all of the Starknet technology and opportunities that enable you to: Build Apps — From groundbreaking dApp or an experimental smart contract, Starknet gives founders the tools and infrastructure to move quickly from idea to IRL. Build Businesses — Take your project from an idea to a MVP or Mainnet product with the support of our ecosystem. @@ -3224,7 +3243,7 @@ Whether you’re preparing to launch an MVP, refining your product for real user Past web3 and/or Starknet contributions and projects will be key in making your application stand out. A compelling Hacker House application portfolio will include: * **Proof of Work** — Showcase your completed projects on platforms like GitHub or personal websites. Highlight any involvement with blockchain, zero-knowledge proofs, or Starknet-specific technologies. -* **Project Progress** — Share details of your current project, emphasizing its development stage. Include information about your MVP, key milestones achieved, and how your work is progressing toward Mainnet or product launch. +* **Project Progress** — Share details of your current project, emphasizing its development stage. Include information about your MVP, key milestones achieved, and how your work is progressing toward Mainnet or product launch. Prove your Cairo experience Starknet’s native programming language, Cairo, is central to the Starknet ecosystem. Your application should highlight your team’s familiarity with it. @@ -4187,7 +4206,7 @@ That critical transformation is finally underway. In this episode, host Nathan J This conversation isn’t just about incremental improvements; it’s about a fundamental reimagining of how we interact with our digital assets, making crypto not just powerful, but practical and accessible for everyone. -### +### ## **From Fintech Darling to Crypto Pioneer** @@ -4201,7 +4220,7 @@ Revolut’s initial masterstroke was its travel card, which eliminated predatory Interestingly, it was Revolut’s entry into crypto during the 2017 bull run that provided a key lesson. “The numbers were just insane,” Chad recalled. Users flocked to the platform because it offered a trusted, one-tap way to buy Bitcoin and Ethereum, running for the hills when they looked at the complex interfaces of traditional crypto exchanges. “Even though Revolut’s fees were a little bit higher than traditional exchanges, people were happy to pay that 0.5% more for that ease of use, but also for the trust.” This proved a critical point: users will pay for simplicity and a name they trust. It’s this exact philosophy that Chad now brings to his work at Ready. -### +### ## **The Bedrock Principle: Why Self-Custody is Everything** @@ -4392,7 +4411,7 @@ A deep dive into how Starknet achieves scale, superior UX, and long-term vision Written by: Lyskey -Aug 5, 2025 · +Aug 5, 2025 · 16 min read ### **TL;DR** @@ -4416,13 +4435,13 @@ Starknet’s PMF in high-level (I’ll break it down to pieces in the next chapt * **Built Different, Therefore Built to Last:** Starknet’s power stems from a courageous, long-term decision to build its technology stack from scratch. Instead of adopting the familiar but limited EVM, Starknet is built on Cairo development language, a custom VM designed specifically for ZK-proofs and provable computation. This difficult path has laid the groundwork for a future of compounding technological superiority that is now becoming evident. * **A Haven for Serious Builders:** In a digital landscape littered with the ghosts of short-term, extractive projects, Starknet stands out as an ecosystem built for resilience and long-term innovation. It attracts and retains builders who are weary of hype cycles and are committed to creating sustainable, meaningful applications on a platform with a multi-cycle vision and a track record of shaping the future of the industry. -### +### ## **Part I: Defining the Market — Who Are We Building For?** Before any product can find its fit, it must have a crystal-clear understanding of its market. For a public L2 like Starknet, the market is twofold: the developers who build on the layer, and the end-users they attract. -#### +#### ### **The Primary Customer: The Developer** @@ -4442,7 +4461,7 @@ This represents the largest potential market by far: the 25-30 million developer While Starknet’s initial focus was on the crypto-native builders, its long-term strategy is increasingly geared towards empowering the UX-first and Web2 developers who will onboard the next billion users. -#### +#### ### **The Secondary Customer: The End User** @@ -4452,7 +4471,7 @@ Developers build, and users come for what they’ve built. The applications flou * **DeFi Users:** This group ranges from sophisticated traders to passive yield seekers. They are drawn to Starknet by the promise of more efficient trading experiences (like those on AMMs such as Ekubo), better yield opportunities through innovative protocols, and advanced use cases that require computational power beyond the EVM’s reach. * **Consumer App Users:** This is the mainstream audience that has been historically unreachable for crypto. They are onboarded through applications with a true Web2-like feel, where the blockchain is entirely invisible. They are often mobile-first, demand low-friction experiences, and have no patience for seed phrases, transaction popups, or network switching. The current generation of blockchain infrastructure serves them poorly, which is precisely the gap Starknet was built to fill. -### +### ### **The Underserved Needs: What the Market is Missing** @@ -4500,9 +4519,9 @@ So, how does Starknet respond to these profound, unmet needs? Let’s move to th ## **Part II: The Product — Starknet’s Answer to the Market** -#### +#### -### +### ### **The Value Proposition: What Starknet Promises** @@ -4553,7 +4572,7 @@ Security without compromise is embedded in Starknet’s DNA. It is designed not * **A Clear Path to Full Decentralization:** Starknet is recognized by the independent auditor L2Beat as a Stage 1 Rollup, with active work already underway to reach Stage 2, at which point the network will be fully trustless with complete escape guarantees for users. In addition, the ecosystem is committed to open-sourcing all its core components, including the upcoming S-two prover and Apollo sequencer, and already boasts the most decentralized stack of any L2 by a wide margin. -* **Decentralizing Without Losing Performance:** Starknet is in the midst of a transition to a decentralized network secured by Proof-of-Stake consensus. This will be powered by STRK staking and, in a novel addition, BTC staking, creating a dual-token security mechanism. Normally, decentralizing a sequencer network introduces latency and slows a network down, as coordination between multiple validators is inherently slower than a single operator. However, Starknet will bypass this trade-off thanks to +* **Decentralizing Without Losing Performance:** Starknet is in the midst of a transition to a decentralized network secured by Proof-of-Stake consensus. This will be powered by STRK staking and, in a novel addition, BTC staking, creating a dual-token security mechanism. Normally, decentralizing a sequencer network introduces latency and slows a network down, as coordination between multiple validators is inherently slower than a single operator. However, Starknet will bypass this trade-off thanks to **Malachite**, a high-performance consensus engine built by Informal Systems. Tests show Malachite can handle ~50k TPS with a latency of just ~780ms across 100 validators. This means that when Starknet transitions to a decentralized sequencer set, it will become more robust and decentralized while *still* maintaining its high performance. Starknet is the real answer to the blockchain trilemma. 3. **A Deep Dive into Blockchain Complexity Abstraction** @@ -5220,7 +5239,7 @@ Next big goals: * Roll out Staking Phases 2 and 3 * Final Phase 4 lands in early 2026, fully decentralizing the sequencer and prover -## +## ## **Starknet Ecosystem Updates** @@ -5237,7 +5256,7 @@ This Perp DEX is no joke—it already delivers a Hyperliquid-style experience: And soon, all of this will run directly on Starknet. -### +### ### **Social Login & EVM Wallets** @@ -5263,7 +5282,7 @@ Here’s how it works: All powered by CASH—the only native stablecoin on Starknet. -### +### ### **Spend Starknet Assets IRL… for Free** @@ -5276,7 +5295,7 @@ Argent just launched its new Lite Card: Also, Cavos is working on a virtual card to let you do the same. -### +### ### **3 New Games Just Dropped** @@ -5288,7 +5307,7 @@ Starknet’s gaming ecosystem is booming with 3 new games live on Mainnet:: The gaming ecosystem is becoming too vast to track? Cartridge Arcade has your back—it’s the hub for all Dojo-powered games. Find games, player profiles, leaderboards, and more. -### +### ### **Starknet Appchains: Full Steam Ahead** @@ -5305,7 +5324,7 @@ Paradex, Starknet’s first live appchain, also tweaked its tokenomics: * Paradigm’s 13.4% allocation now unlocks on a linear, performance-based schedule * 85% of the codebase has been audited by Cairo Audit -## +## ## **Alpha Zone: New Launches in May** @@ -5355,7 +5374,7 @@ Jun 30, 2025 · 6 min read Welcome to the 23rd edition of the monthly recap, your go-to source for the most significant updates and developments within the Starknet ecosystem. -### +### ## **Key Highlights of the Month** @@ -5400,7 +5419,7 @@ The subsequent major release, **Starknet v0.14.0**, is planned for Mainnet in mi Developers should review this version thoroughly due to the introduction of breaking changes. -#### +#### ### **Enhanced Performance, UX/DevX, and Decentralization** @@ -5420,7 +5439,7 @@ In addition to Staking v2, StarkWare has revealed its plans to participate in ST On a related note, **Figment** now provides support for STRK staking, enabling institutions to delegate their STRK to Figment. -### +### ## **Starknet Ecosystem Updates** @@ -5452,7 +5471,7 @@ The **Wolf Pack League** has officially launched, creating a program that allows * Example of what you can build with it * Here’s how to get started -#### +#### ### **Endur Points Program & Airdrop** @@ -5466,7 +5485,7 @@ The **Wolf Pack League** has officially launched, creating a program that allows * **Blob Arena** had its full launch during a major live sports event, reaching an audience of thousands. * **zkLend** is shutting down, with both its Money Market and liquid staking services being discontinued. -#### +#### ### **Alpha Zone** @@ -5476,11 +5495,11 @@ Three new projects went live on Starknet Mainnet this month: * **Lutte Arcade**, a battler set in the lootverse. * **Karat**, a new NFT collection. -### +### -### +### -### +### ## **Top Content of the Month** @@ -5501,7 +5520,7 @@ Discover how **S-two**, StarkWare’s next-generation prover, is enabling partne When it comes to performance, S-two has significantly surpassed its competitors. See more here. -### +### *Disclaimer: This blog post was written by 0xLyskey,, a community member. The views, thoughts, and opinions expressed in the text belong solely to the author. This content is provided for informational purposes only and should not be construed as financial, investment, or any other form of advice. Readers are solely responsible for their own decisions and are strongly encouraged to conduct their own research. Stay safe and do your own research.* @@ -5820,7 +5839,7 @@ How much supply is “wasted” on exorbitantly high prices? Consider a $\overbr Some example computations show the extreme capital inefficiency of the constant-product curve. -### +### ### Depth in general @@ -7033,52 +7052,52 @@ More ecosystem products that align with the vision of BTCFi on Starknet. Stay tu ## General -* What is BTCFi Season? +* What is BTCFi Season? BTCFi Season is an incentive program launched by the Starknet Foundation to bootstrap BTC liquidity and stablecoin borrowing activity against BTC on Starknet. -* What is BTCFi Season’s purpose? +* What is BTCFi Season’s purpose? BTCFi Season is an important piece of the broader BTCFi on Starknet initiative that is designed to enable the activities that will kickstart a flywheel effect for sustainable BTC yield -consistent, predictable and competitive, driven by real economic activity- and ecosystem growth on Starknet. -* Which DeFi verticals does BTCFi Season support? +* Which DeFi verticals does BTCFi Season support? BTCFi Season supports the DEX and Money Market verticals. -* What activity will BTCFi Season support? +* What activity will BTCFi Season support? BTCFi Season supports protocols that enable highly liquid BTC pools on DEXs and Money Markets and borrowing of stablecoins against BTC collateral. -* What assets and pairs will be eligible for incentives? +* What assets and pairs will be eligible for incentives? You can find an updated list of eligible assets and pairs on BTCFi Season’s website. -* When does BTCFi Season launch? +* When does BTCFi Season launch? BTCFi Season launched on September 30th, 2025. -* How long will BTCFi Season last? +* How long will BTCFi Season last? The program is set to run for a minimum of six months, with the potential to continue well beyond that. ## I am a User -* How do I know if a project is a participating protocol in BTCFi Season and will be distributing STRK rewards? +* How do I know if a project is a participating protocol in BTCFi Season and will be distributing STRK rewards? You can find an updated list of eligible protocols on BTCFi Season’s website. -* How do I know what actions are eligible for STRK rewards? +* How do I know what actions are eligible for STRK rewards? You will need to explore the individual participating protocols and their terms of use to see how you can earn STRK through their programs. -* How can I claim my STRK from BTCFi Season? +* How can I claim my STRK from BTCFi Season? You will need to follow the guidelines provided from the individual participating protocols as they are responsible for their own distribution of STRK to their users based on their terms of use and announced programs. -* What happens if I don’t claim my STRK from BTCFi Season? +* What happens if I don’t claim my STRK from BTCFi Season? You will be able to claim your STRK within each participating protocol. Any unclaimed STRK at the end of BTCFi Season will be returned back to the Foundation. ## I am a Protocol -* How can I participate in BTCFi Season? +* How can I participate in BTCFi Season? The Starknet Foundation determines the appropriateness of participating protocols in its absolute discretion and is focused solely on protocols that support the DEX and Money Market verticals. If you are interested in participating in BTCFi Season, please apply using this [form] and we will be in touch shortly. -* What criteria should I use for my incentive program? +* What criteria should I use for my incentive program? Each protocol shall determine its own criteria for rewarding users, deciding both which users qualify and how rewards are allocated on eligible activity and assets/pairs. -* Am I required to make the criteria of my incentive program public? +* Am I required to make the criteria of my incentive program public? Yes. Announcing your incentive program’s criteria and terms of use is a mandatory requirement to participate in BTCFi Season. diff --git a/python/src/cairo_coder_tools/ingestion/web_targets.py b/python/src/cairo_coder_tools/ingestion/web_targets.py new file mode 100644 index 00000000..21e7e228 --- /dev/null +++ b/python/src/cairo_coder_tools/ingestion/web_targets.py @@ -0,0 +1,181 @@ +import re +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Optional, Protocol + + +class IWebsiteTarget(Protocol): + """A protocol defining the interface for a website ingestion target.""" + + @property + def name(self) -> str: + """Unique identifier for this target.""" + ... + + @property + def base_url(self) -> str: + """Base URL to start crawling from.""" + ... + + def get_include_url_patterns(self) -> Optional[list[str]]: + """Get regex patterns for URLs to include.""" + ... + + def get_exclude_url_patterns(self) -> Optional[list[str]]: + """Get regex patterns for URLs to exclude.""" + ... + + def filter_content(self, content: str) -> bool: + """Return True if content should be kept, False to filter out.""" + ... + + def process_content(self, content: str) -> str: + """Post-process content (e.g., remove unwanted sections).""" + ... + + def get_default_output_path(self) -> Path: + """Get the default output path for this target.""" + ... + + +def _default_filter(content: str) -> bool: + """Accept all content by default.""" + return True + + +def _default_processor(content: str) -> str: + """Pass through content unchanged by default.""" + return content + + +@dataclass +class WebTargetConfig: + """A dataclass implementation of the IWebsiteTarget protocol. + + This class uses composition to bundle together URL patterns, filtering + logic, and content processing logic. It structurally satisfies the + IWebsiteTarget protocol without explicit inheritance. + + Example: + >>> def my_filter(content: str) -> bool: + ... return "2025" in content + >>> target = WebTargetConfig( + ... name="example", + ... base_url="https://example.com", + ... content_filter=my_filter + ... ) + """ + + name: str + base_url: str + include_patterns: Optional[list[str]] = None + exclude_patterns: Optional[list[str]] = None + content_filter: Callable[[str], bool] = _default_filter + content_processor: Callable[[str], str] = _default_processor + + def get_include_url_patterns(self) -> Optional[list[str]]: + return self.include_patterns + + def get_exclude_url_patterns(self) -> Optional[list[str]]: + return self.exclude_patterns + + def filter_content(self, content: str) -> bool: + return self.content_filter(content) + + def process_content(self, content: str) -> str: + return self.content_processor(content) + + def get_default_output_path(self) -> Path: + import os + return Path(f"{os.getcwd()}/src/cairo_coder_tools/ingestion/generated/{self.name}.md") + + +def is_2025_blog_entry(content: str) -> bool: + """Check if content is a blog entry from 2025. + + Looks for patterns like: + Home / Blog + Apr 3, 2025 · 3 min read + OR + Home / Blog + Share this post: + Jul 29, 2025 + """ + # Pattern 1: Month Day, Year · X min read + # Example: "Apr 3, 2025 · 3 min read" + pattern1 = r'Home\s+/\s+Blog.*?(\w+\s+\d+,\s+(\d{4}))\s*·' + + # Pattern 2: Month Day, Year (without the · min read) + # Example: "Jul 29, 2025" after "Share this post:" + pattern2 = r'Home\s+/\s+Blog.*?Share this post:.*?(\w+\s+\d+,\s+(\d{4}))' + + # Pattern 3: Just Month Day, Year with min read + # Example: "Nov 26, 2024 · 3 min read" + pattern3 = r'(\w+\s+\d+,\s+(\d{4}))\s*·.*?min read' + + for pattern in [pattern1, pattern2, pattern3]: + matches = re.findall(pattern, content, re.DOTALL | re.IGNORECASE) + for match in matches: + year = match[1] if len(match) > 1 else match[-1] + if year == '2025': + return True + + return False + + +def clean_blog_content(content: str) -> str: + """Remove unwanted sections from blog content. + + Removes: + - "Join our newsletter" section and its content + - "May also interest you" section and its content + """ + # Remove "Join our newsletter" section and everything after it until next header + # Match any header level (##, ###, ####, etc.) + content = re.sub( + r'^#{2,}\s*Join our newsletter.*?(?=^#{2,}|\Z)', + '', + content, + flags=re.DOTALL | re.IGNORECASE | re.MULTILINE, + ) + + # Remove "May also interest you" section and everything after it + # Match any header level (##, ###, ####, etc.) + content = re.sub( + r'^#{2,}\s*May also interest you.*?(?=^#{2,}|\Z)', + '', + content, + flags=re.DOTALL | re.IGNORECASE | re.MULTILINE, + ) + + # Also try to catch variations without markdown headers (plain text) + content = re.sub( + r'Join our newsletter.*?(?=\n\n[A-Z]|\Z)', '', content, flags=re.DOTALL | re.IGNORECASE + ) + + content = re.sub( + r'May also interest you.*?(?=\n\n[A-Z]|\Z)', '', content, flags=re.DOTALL | re.IGNORECASE + ) + + # Clean up multiple newlines + content = re.sub(r'\n{3,}', '\n\n', content) + + return content.strip() + + +# ============================================================================ +# Predefined Targets +# ============================================================================ + +STARKNET_BLOG = WebTargetConfig( + name="starknet-blog", + base_url="https://www.starknet.io/blog", + exclude_patterns=[r'video/$'], # Exclude URLs ending with video/ + content_filter=is_2025_blog_entry, + content_processor=clean_blog_content, +) + +PREDEFINED_TARGETS: dict[str, IWebsiteTarget] = { + STARKNET_BLOG.name: STARKNET_BLOG, +} diff --git a/python/src/scripts/README.md b/python/src/scripts/README.md deleted file mode 100644 index c985de49..00000000 --- a/python/src/scripts/README.md +++ /dev/null @@ -1,164 +0,0 @@ -# Cairo Coder Scripts - -This directory contains the main CLI entrypoints for Cairo Coder workflows. All business logic has been moved to the `cairo_coder` library package for better maintainability and reusability. - -## Available Commands - -Cairo Coder provides three main CLI tools for different workflows: - -### 1. `eval` - Evaluation Tool - -Evaluate Cairo Coder's performance using various test suites. - -```bash -# Run Starklings evaluation -uv run eval --runs 3 --output-dir ./results - -# Evaluate specific category -uv run eval --category "intro" --max-concurrent 5 - -# Full options -uv run eval --help -``` - -**Key Features:** -- Evaluates Cairo Coder against Starklings exercises -- Generates detailed reports with success rates -- Supports concurrent evaluation for speed -- Configurable API endpoints and models - -### 2. `ingest` - Data Ingestion Tool - -Ingest documentation from various sources into a format suitable for the RAG pipeline. - -```bash -# Ingest from a Git repository -uv run ingest from-git https://github.com/cairo-book/cairo-book \ - --type mdbook \ - --output cairo_book_summary.md - -# Crawl a website using predefined target (automatically filters for 2025) -uv run ingest from-web starknet-blog-2025 - -# Or crawl manually with custom filter -uv run ingest from-web https://www.starknet.io/blog \ - --content-filter="2025" \ - --output starknet_blog_2025.md - -# Fix markdown headers -uv run ingest fix-headers input.md --output output.md - -# List available options -uv run ingest list-targets -uv run ingest list-types -``` - -**Key Features:** -- Git repository ingestion with LLM summarization -- Web crawling with filtering capabilities -- Support for mdbook and other documentation types -- Header fixing utilities for better formatting - -### 3. `dataset` - Dataset Management Tool - -Extract, generate, and analyze datasets for Cairo Coder. - -```bash -# Extract QA pairs from LangSmith exports -uv run dataset extract starknet-agent \ - --input export.jsonl \ - --output qa_pairs.json - -uv run dataset extract cairo-coder \ - --input traces.jsonl \ - --output pairs.json \ - --only-generated-answers - -# Generate synthetic datasets -uv run dataset generate starklings \ - --output starklings_dataset.json - -# Analyze a dataset with LLM -uv run dataset analyze \ - --input qa_pairs.json \ - --output analysis.json \ - --model "openrouter/x-ai/grok-4-fast:free" -``` - -**Key Features:** -- Extract QA pairs from various export formats -- Generate datasets from Starklings exercises -- LLM-powered dataset analysis -- De-duplication and filtering - -## Architecture - -The refactored architecture follows these principles: - -1. **Separation of Concerns**: Business logic lives in `cairo_coder/`, scripts are just thin entrypoints -2. **Workflow-Oriented**: Commands are organized by workflow (eval, ingest, dataset) not by implementation -3. **Reusability**: All logic can be imported and used programmatically - -### Directory Structure - -``` -python/src/ -├── cairo_coder/ # Main library package -│ ├── dspy/ # DSPy RAG pipeline -│ ├── server/ # FastAPI server -│ ├── datasets/ # Dataset extractors (existing) -│ └── ... -├── cairo_coder_tools/ # Tools library package -│ ├── evals/ # Evaluation logic -│ │ └── starklings/ # Starklings evaluation suite -│ ├── ingestion/ # Data ingestion logic -│ │ ├── crawler.py # Web crawler -│ │ └── ... # Summarizers, etc. -│ └── datasets/ # Dataset analysis utilities -│ └── analysis.py # LLM-based analysis -└── scripts/ # CLI entrypoints only - ├── eval.py # Evaluation CLI - ├── ingest.py # Ingestion CLI - └── dataset.py # Dataset CLI -``` - -## Migration Guide - -If you were using the old scripts, here's how to migrate: - -| Old Command | New Command | -|------------|-------------| -| `uv run starklings_evaluate` | `uv run eval` | -| `uv run cairo-coder-summarize` | `uv run ingest from-git` | -| `uv run docs-crawler` | `uv run ingest from-web` | -| `uv run filter_2025_blogs` | `uv run ingest from-web starknet-blog-2025` | -| `uv run cairo-coder-datasets extract` | `uv run dataset extract` | -| `uv run cairo-coder-datasets generate` | `uv run dataset generate` | -| N/A | `uv run dataset analyze` (new!) | - -## Getting Help - -Each command has detailed help text: - -```bash -uv run eval --help -uv run ingest --help -uv run dataset --help -``` - -For subcommands: - -```bash -uv run ingest from-git --help -uv run dataset extract --help -``` - -## Development - -To add new functionality: - -1. Add the core logic to the appropriate module in `cairo_coder/` -2. Add a new subcommand or option to the relevant CLI in `scripts/` -3. Update this README - -This keeps the codebase maintainable and testable. diff --git a/python/src/scripts/dataset.py b/python/src/scripts/dataset.py index 87b2bc09..2ade8628 100644 --- a/python/src/scripts/dataset.py +++ b/python/src/scripts/dataset.py @@ -13,11 +13,11 @@ import typer from typer.core import TyperGroup +from cairo_coder_tools.datasets.analysis import analyze_dataset from cairo_coder_tools.datasets.extractors import ( extract_cairocoder_pairs, extract_starknet_agent_pairs, ) -from cairo_coder_tools.datasets.analysis import analyze_dataset class HelpOnInvalidCommand(TyperGroup): diff --git a/python/src/scripts/ingest.py b/python/src/scripts/ingest.py index 8b1dbae6..3c4fc897 100644 --- a/python/src/scripts/ingest.py +++ b/python/src/scripts/ingest.py @@ -6,7 +6,6 @@ """ import asyncio -import re import resource from enum import Enum from pathlib import Path @@ -20,89 +19,11 @@ from cairo_coder_tools.ingestion.crawler import DocsCrawler from cairo_coder_tools.ingestion.header_fixer import HeaderFixer from cairo_coder_tools.ingestion.summarizer_factory import DocumentationType, SummarizerFactory - - -def is_2025_blog_entry(content: str) -> bool: - """Check if content is a blog entry from 2025. - - Looks for patterns like: - Home / Blog - Apr 3, 2025 · 3 min read - OR - Home / Blog - Share this post: - Jul 29, 2025 - """ - import re - - # Pattern 1: Month Day, Year · X min read - # Example: "Apr 3, 2025 · 3 min read" - pattern1 = r'Home\s+/\s+Blog.*?(\w+\s+\d+,\s+(\d{4}))\s*·' - - # Pattern 2: Month Day, Year (without the · min read) - # Example: "Jul 29, 2025" after "Share this post:" - pattern2 = r'Home\s+/\s+Blog.*?Share this post:.*?(\w+\s+\d+,\s+(\d{4}))' - - # Pattern 3: Just Month Day, Year with min read - # Example: "Nov 26, 2024 · 3 min read" - pattern3 = r'(\w+\s+\d+,\s+(\d{4}))\s*·.*?min read' - - for pattern in [pattern1, pattern2, pattern3]: - matches = re.findall(pattern, content, re.DOTALL | re.IGNORECASE) - for match in matches: - year = match[1] if len(match) > 1 else match[-1] - if year == '2025': - return True - - return False - - -def clean_blog_content(content: str) -> str: - """Remove unwanted sections from blog content. - - Removes: - - "Join our newsletter" section and its content - - "May also interest you" section and its content - """ - import re - - # Remove "Join our newsletter" section and everything after it until next header - # Match any header level (##, ###, ####, etc.) - content = re.sub( - r'^#{2,}\s*Join our newsletter.*?(?=^#{2,}|\Z)', - '', - content, - flags=re.DOTALL | re.IGNORECASE | re.MULTILINE - ) - - # Remove "May also interest you" section and everything after it - # Match any header level (##, ###, ####, etc.) - content = re.sub( - r'^#{2,}\s*May also interest you.*?(?=^#{2,}|\Z)', - '', - content, - flags=re.DOTALL | re.IGNORECASE | re.MULTILINE - ) - - # Also try to catch variations without markdown headers (plain text) - content = re.sub( - r'Join our newsletter.*?(?=\n\n[A-Z]|\Z)', - '', - content, - flags=re.DOTALL | re.IGNORECASE - ) - - content = re.sub( - r'May also interest you.*?(?=\n\n[A-Z]|\Z)', - '', - content, - flags=re.DOTALL | re.IGNORECASE - ) - - # Clean up multiple newlines - content = re.sub(r'\n{3,}', '\n\n', content) - - return content.strip() +from cairo_coder_tools.ingestion.web_targets import ( + PREDEFINED_TARGETS, + IWebsiteTarget, + WebTargetConfig, +) # Load environment variables load_dotenv() @@ -120,13 +41,6 @@ class TargetRepo(str, Enum): # Add more repositories as needed -class TargetWebsite(str, Enum): - """Predefined target websites for web crawling""" - - STARKNET_BLOG_2025 = "https://www.starknet.io/blog" - # Add more websites as needed - - @app.command(name="from-git") def from_git( repo_url: str = typer.Argument(help="GitHub repository URL to summarize."), @@ -197,7 +111,9 @@ def from_git( @app.command(name="from-web") def from_web( url: str = typer.Argument(help="Base URL of website to crawl, or predefined target name."), - output: Path = typer.Option(Path("doc_dump.md"), "--output", "-o", help="Output file path"), + output: Optional[Path] = typer.Option( + None, "--output", "-o", help="Output file path (uses target default if not specified)" + ), content_filter: Optional[str] = typer.Option( None, "--content-filter", @@ -218,7 +134,7 @@ def from_web( Examples: # Use predefined target for StarkNet 2025 blog posts - uv run ingest from-web starknet-blog-2025 --output starknet_blog_2025.md + uv run ingest from-web starknet-blog-2025 # Crawl StarkNet blog manually with filter uv run ingest from-web https://www.starknet.io/blog --content-filter="2025" @@ -227,63 +143,48 @@ def from_web( uv run ingest from-web https://example.com --include-patterns="/docs/,/api/" """ - # Check for predefined website targets - actual_url = url - auto_filter_func = None - auto_processor_func = None - auto_exclude_patterns = None - auto_output = None - - if url.upper().replace("-", "_") in [t.name for t in TargetWebsite]: - target = TargetWebsite[url.upper().replace("-", "_")] - actual_url = target.value - - # Apply automatic settings for specific targets - if target == TargetWebsite.STARKNET_BLOG_2025: - auto_filter_func = is_2025_blog_entry - auto_processor_func = clean_blog_content - auto_exclude_patterns = [r'video\/$'] # Exclude URLs ending with video/ - auto_output = Path("starknet_blog_2025.md") - typer.echo(f"Using predefined target: {target.name.lower().replace('_', '-')}") - typer.echo(f" URL: {actual_url}") - typer.echo(f" Auto-filter: 2025 blog entries") - typer.echo(f" Auto-cleanup: Removing newsletter and interest sections") - typer.echo(f" Auto-exclude: Skipping /video/ URLs") - if output == Path("doc_dump.md"): # Only use auto output if user didn't specify - output = auto_output - typer.echo(f" Output: {output}") - - # Parse include patterns if provided - include_pattern_list = None - if include_patterns: - include_pattern_list = [p.strip() for p in include_patterns.split(",")] - - # Use auto exclude patterns if available - exclude_pattern_list = auto_exclude_patterns - - # Create content filter function - content_filter_func = None - if content_filter: - # Manual filter takes precedence - def filter_func(content: str) -> bool: - return content_filter in content - - content_filter_func = filter_func - elif auto_filter_func: - # Use auto filter from predefined target - content_filter_func = auto_filter_func - - # Use content processor from predefined target if available - content_processor_func = auto_processor_func + target: IWebsiteTarget + + # Check if this is a predefined target + if url in PREDEFINED_TARGETS: + target = PREDEFINED_TARGETS[url] + typer.echo(f"Using predefined target: {target.name}") + typer.echo(f" URL: {target.base_url}") + if target.get_exclude_url_patterns(): + typer.echo(f" Exclude patterns: {target.get_exclude_url_patterns()}") + # Show details for specific targets + if target.name == "starknet-blog-2025": + typer.echo(" Content filter: 2025 blog entries only") + typer.echo(" Content processor: removes newsletter/interest sections") + else: + # Create a generic target on the fly for custom URLs + include_pattern_list = None + if include_patterns: + include_pattern_list = [p.strip() for p in include_patterns.split(",")] + + # Create content filter function if provided + content_filter_func = None + if content_filter: + + def filter_func(content: str) -> bool: + return content_filter in content + + content_filter_func = filter_func + + target = WebTargetConfig( + name=url.split("/")[-1] or "custom", + base_url=url, + include_patterns=include_pattern_list, + content_filter=content_filter_func if content_filter_func else lambda _: True, + ) + + # Use target's default output path if user didn't specify one + if output is None: + output = target.get_default_output_path() + typer.echo(f" Output: {output}") async def run_crawler() -> None: - async with DocsCrawler( - base_url=actual_url, - include_patterns=include_pattern_list, - exclude_url_patterns=exclude_pattern_list, - content_filter=content_filter_func, - content_processor=content_processor_func, - ) as crawler: + async with DocsCrawler(target=target) as crawler: output_path = await crawler.run(output) typer.echo( typer.style( @@ -310,15 +211,10 @@ def list_targets() -> None: typer.echo(f" - {target.name.lower().replace('_', '-')}: {target.value}") typer.echo("\nWebsite Targets (use with 'from-web'):") - for target in TargetWebsite: - name = target.name.lower().replace('_', '-') - typer.echo(f" - {name}: {target.value}") - # Show special features for specific targets - if target == TargetWebsite.STARKNET_BLOG_2025: - typer.echo(f" → Skips video URLs (ending with /video/)") - typer.echo(f" → Filters for 2025 blog entries only") - typer.echo(f" → Removes 'Join our newsletter' sections") - typer.echo(f" → Removes 'May also interest you' sections") + for name, target in PREDEFINED_TARGETS.items(): + typer.echo(f" - {name}: {target.base_url}") + if target.get_exclude_url_patterns(): + typer.echo(f" → Excludes URLs matching: {', '.join(target.get_exclude_url_patterns())}") @app.command(name="list-types") From a01d93fd7d38253deec92c79314e172138822c86 Mon Sep 17 00:00:00 2001 From: enitrat Date: Sun, 26 Oct 2025 08:30:10 +0100 Subject: [PATCH 3/4] update docs --- AGENTS.md | 23 ++++++++++++----------- API_DOCUMENTATION.md | 22 +++++++++++++++++----- ingesters/README.md | 14 +++++++------- python/README.md | 1 - 4 files changed, 36 insertions(+), 24 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 9bd180b9..f2c33911 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -6,23 +6,24 @@ This file documents conventions and checklists for making changes that affect th When adding a new documentation source (e.g., a new docs site or SDK) make sure to complete all of the following steps: -1. TypeScript ingestion (packages/ingester) +1. TypeScript ingestion (ingesters) - - Create an ingester class extending `BaseIngester` or `MarkdownIngester` under `packages/ingester/src/ingesters/`. - - Register it in `packages/ingester/src/IngesterFactory.ts`. + - Create an ingester class extending `BaseIngester` or `MarkdownIngester` under `ingesters/src/ingesters/`. + - Register it in `ingesters/src/IngesterFactory.ts`. - Ensure chunks carry correct metadata: `uniqueId`, `contentHash`, `sourceLink`, and `source`. - - Run `pnpm generate-embeddings` (or `generate-embeddings:yes`) to populate/update the vector store. + - Run the embeddings generator to populate/update the vector store: + - Prefer: `bun run src/generateEmbeddings.ts` (or `bun run src/generateEmbeddings.ts -y`) + - If you have scripts wired: `bun run generate-embeddings` (or `generate-embeddings:yes`) -2. Agents (TS) +2. Agents (Python) - - Add the new enum value to `packages/agents/src/types/index.ts` under `DocumentSource`. - - Verify Postgres vector store accepts the new `source` and filters on it (`packages/agents/src/db/postgresVectorStore.ts`). + - Add the new enum value to `python/src/cairo_coder/core/types.py` under `DocumentSource`. + - Ensure filtering by `metadata->>'source'` works with the new value in `python/src/cairo_coder/dspy/document_retriever.py`. + - Update the query processor resource descriptions in `python/src/cairo_coder/dspy/query_processor.py` (`RESOURCE_DESCRIPTIONS`). The module validates that every `DocumentSource` has a description. 3. Retrieval Pipeline (Python) - - Add the new enum value to `python/src/cairo_coder/core/types.py` under `DocumentSource`. - - Ensure filtering by `metadata->>'source'` works with the new value in `python/src/cairo_coder/dspy/document_retriever.py`. - - Update the query processor resource descriptions in `python/src/cairo_coder/dspy/query_processor.py` (`RESOURCE_DESCRIPTIONS`). + - No extra steps beyond the above; the retriever already supports filtering by `metadata->>'source'`. 4. Optimized Program Files (Python) — required @@ -34,7 +35,7 @@ When adding a new documentation source (e.g., a new docs site or SDK) make sure - Ensure the new source appears where appropriate (e.g., `/v1/agents` output and documentation tables): - `API_DOCUMENTATION.md` - - `packages/ingester/README.md` + - `ingesters/README.md` - Any user-facing lists of supported sources 6. Quick Sanity Check diff --git a/API_DOCUMENTATION.md b/API_DOCUMENTATION.md index c57706e7..65a02c95 100644 --- a/API_DOCUMENTATION.md +++ b/API_DOCUMENTATION.md @@ -58,14 +58,25 @@ Lists every agent registered in Cairo Coder. "openzeppelin_docs", "corelib_docs", "scarb_docs", - "starknet_js" + "starknet_js", + "starknet_blog" ] }, { - "id": "scarb-assistant", - "name": "Scarb Assistant", - "description": "Specialized assistant for Scarb build tool", - "sources": ["scarb_docs"] + "id": "starknet-agent", + "name": "Starknet Agent", + "description": "Assistant for the Starknet ecosystem (contracts, tools, docs).", + "sources": [ + "cairo_book", + "starknet_docs", + "starknet_foundry", + "cairo_by_example", + "openzeppelin_docs", + "corelib_docs", + "scarb_docs", + "starknet_js", + "starknet_blog" + ] } ] ``` @@ -82,6 +93,7 @@ Lists every agent registered in Cairo Coder. | `corelib_docs` | Cairo core library docs | | `scarb_docs` | Scarb package manager documentation | | `starknet_js` | StarknetJS guides and SDK documentation | +| `starknet_blog` | Starknet blog posts and announcements | ## Chat Completions diff --git a/ingesters/README.md b/ingesters/README.md index 02cdb0e1..d7b8e7f0 100644 --- a/ingesters/README.md +++ b/ingesters/README.md @@ -32,6 +32,7 @@ The ingester currently supports the following documentation sources: 6. **Core Library Docs** (`corelib_docs`): Cairo core library documentation 7. **Scarb Docs** (`scarb_docs`): Scarb package manager documentation 8. **StarknetJS Guides** (`starknet_js`): StarknetJS guides and tutorials +9. **Starknet Blog** (`starknet_blog`): Starknet blog posts and announcements ## Architecture @@ -112,17 +113,16 @@ const chunks = splitter.splitMarkdownToChunks(markdown); ## Usage -To use the ingester package, run the `generateEmbeddings.ts` script: +To use the ingester package, run the embeddings generator script: ```bash -# From the root of the package -pnpm run generate-embeddings - -# From the root of the project -turbo run generate-embeddings +# Preferred (direct bun): +bun run src/generateEmbeddings.ts +# Non-interactive (yes to prompts): +bun run src/generateEmbeddings.ts -y ``` -This will prompt you to select a documentation source to ingest. You can also select "Everything" to ingest all sources. +This will prompt you to select a documentation source to ingest (or use `-y` for all). You can also select "Everything" to ingest all sources. ## Adding a New Documentation Source diff --git a/python/README.md b/python/README.md index 5480efbf..eccfe817 100644 --- a/python/README.md +++ b/python/README.md @@ -82,7 +82,6 @@ docker compose up postgres backend --build ```bash curl -X POST "http://localhost:3001/v1/chat/completions" \ -H "Content-Type: application/json" \ - -H "x-api-key: YOUR_API_KEY" \ -d '{ "messages": [ { From ed901c21e7116aa55268ef9bfe598cd6528179e6 Mon Sep 17 00:00:00 2001 From: enitrat Date: Sun, 26 Oct 2025 08:42:04 +0100 Subject: [PATCH 4/4] fix md splitter header parsing --- ingesters/src/ingesters/AsciiDocIngester.ts | 2 +- ingesters/src/utils/RecursiveMarkdownSplitter.ts | 13 +++++++++---- .../__tests__/RecursiveMarkdownSplitter.test.ts | 13 +++++++++++++ 3 files changed, 23 insertions(+), 5 deletions(-) diff --git a/ingesters/src/ingesters/AsciiDocIngester.ts b/ingesters/src/ingesters/AsciiDocIngester.ts index 6870a595..a8831d4e 100644 --- a/ingesters/src/ingesters/AsciiDocIngester.ts +++ b/ingesters/src/ingesters/AsciiDocIngester.ts @@ -237,7 +237,7 @@ export abstract class AsciiDocIngester extends BaseIngester { sections.forEach((section: ParsedSection, index: number) => { const hash: string = calculateHash(section.content); const sourceLink = `${this.config.baseUrl}/${page.name}${this.config.urlSuffix}${section.anchor ? '#' + section.anchor : ''}`; - console.debug( + logger.debug( `Section Title: ${section.title}, source: ${this.source}, sourceLink: ${sourceLink}`, ); chunks.push( diff --git a/ingesters/src/utils/RecursiveMarkdownSplitter.ts b/ingesters/src/utils/RecursiveMarkdownSplitter.ts index 02fa592b..6d6bb42f 100644 --- a/ingesters/src/utils/RecursiveMarkdownSplitter.ts +++ b/ingesters/src/utils/RecursiveMarkdownSplitter.ts @@ -199,7 +199,8 @@ export class RecursiveMarkdownSplitter { const sourceRanges = this.parseSourceRanges(markdown); // Find all headers - const headerRegex = /^(#{1,6})\s+(.+?)(?:\s*#*)?$/gm; + // Allow up to 3 leading spaces before ATX headers per CommonMark + const headerRegex = /^\s{0,3}(#{1,6})\s+(.+?)(?:\s*#*)?$/gm; let match: RegExpExecArray | null; while ((match = headerRegex.exec(markdown)) !== null) { @@ -214,10 +215,14 @@ export class RecursiveMarkdownSplitter { // Find all code blocks this.findCodeBlocks(markdown, codeBlocks); - // Filter out headers that are inside code blocks + // Filter out headers that are inside non-breakable code blocks + // Allow headers inside oversized or malformed (breakable) code blocks const filteredHeaders = headers.filter((header) => { return !codeBlocks.some( - (block) => header.start >= block.start && header.end <= block.end, + (block) => + header.start >= block.start && + header.end <= block.end && + !block.breakable, ); }); @@ -950,7 +955,7 @@ export class RecursiveMarkdownSplitter { } } - console.debug(`Chunk Title: ${title}, Source link: ${sourceLink}`); + logger.debug(`Chunk Title: ${title}, Source link: ${sourceLink}`); chunks.push({ content: rawChunk.content, diff --git a/ingesters/src/utils/__tests__/RecursiveMarkdownSplitter.test.ts b/ingesters/src/utils/__tests__/RecursiveMarkdownSplitter.test.ts index 5a51f20b..286bc009 100644 --- a/ingesters/src/utils/__tests__/RecursiveMarkdownSplitter.test.ts +++ b/ingesters/src/utils/__tests__/RecursiveMarkdownSplitter.test.ts @@ -124,6 +124,19 @@ More content.`; expect(chunks[0]!.meta.title).toBe('Header with trailing hashes'); }); + it('should detect headers with up to 3 leading spaces', () => { + const splitter = new RecursiveMarkdownSplitter({ + maxChars: 100, + minChars: 0, + overlap: 0, + headerLevels: [1, 2], + }); + const text = ' ## Indented H2 Header\nBody under indented header.'; + const chunks = splitter.splitMarkdownToChunks(text); + expect(chunks.length).toBeGreaterThanOrEqual(1); + expect(chunks[0]!.meta.title).toBe('Indented H2 Header'); + }); + it('should prefer deepest header of configured levels (e.g., H2) for title', () => { const splitter = new RecursiveMarkdownSplitter({ maxChars: 80,