Easy like sign, send, done

Python Smart Contracts. For Real.

Python Smart Contracts. For Real.

Python Smart Contracts. For Real.

Nano Contracts bring the world’s most loved language to blockchain

Nano Contracts bring the world’s most loved language to blockchain

Nano Contracts bring the world’s most loved language to blockchain

Try in AI Playground

Try in AI Playground

Try in AI Playground

Read Docs

Read Docs

Read Docs

Is it really Python?

Yes. Take a look for yourself

It's as close to a native Python experience as blockchain development gets: no new syntax, no obscure virtual machines, just Python.

from hathor.nanocontracts import Blueprint
from hathor.nanocontracts.context import Context
from hathor.nanocontracts.exception import NCFail
from hathor.nanocontracts.types import public, view

class SimpleCounter(Blueprint):
    """A simple counter that can be incremented and read"""

    # Contract state
    count: int

    @public
    def initialize(self, ctx: Context) -> None:
        """Initialize the counter"""
        self.count = 0

    @public
    def increment(self, ctx: Context, amount: int) -> None:
        """Increment the counter by the specified amount"""
        if amount <= 0:
            raise NegativeIncrement("Amount must be positive")

        self.count += amount

    @view
    def get_count(self) -> int:
        """Get the current counter value"""
        return self.count

    @public
    def reset(self, ctx: Context) -> None:
        """Reset the counter to zero"""

class NegativeIncrement(NCFail):
    pass

Expand

⌄

from hathor.nanocontracts import Blueprint
from hathor.nanocontracts.context import Context
from hathor.nanocontracts.exception import NCFail
from hathor.nanocontracts.types import public, view

class SimpleCounter(Blueprint):
    """A simple counter that can be incremented and read"""

    # Contract state
    count: int

    @public
    def initialize(self, ctx: Context) -> None:
        """Initialize the counter"""
        self.count = 0

    @public
    def increment(self, ctx: Context, amount: int) -> None:
        """Increment the counter by the specified amount"""
        if amount <= 0:
            raise NegativeIncrement("Amount must be positive")

        self.count += amount

    @view
    def get_count(self) -> int:
        """Get the current counter value"""
        return self.count

    @public
    def reset(self, ctx: Context) -> None:
        """Reset the counter to zero"""

class NegativeIncrement(NCFail):
    pass

Expand

⌄

from hathor.nanocontracts import Blueprint
from hathor.nanocontracts.context import Context
from hathor.nanocontracts.exception import NCFail
from hathor.nanocontracts.types import public, view

class SimpleCounter(Blueprint):
    """A simple counter that can be incremented and read"""

    # Contract state
    count: int

    @public
    def initialize(self, ctx: Context) -> None:
        """Initialize the counter"""
        self.count = 0

    @public
    def increment(self, ctx: Context, amount: int) -> None:
        """Increment the counter by the specified amount"""
        if amount <= 0:
            raise NegativeIncrement("Amount must be positive")

        self.count += amount

    @view
    def get_count(self) -> int:
        """Get the current counter value"""
        return self.count

    @public
    def reset(self, ctx: Context) -> None:
        """Reset the counter to zero"""

class NegativeIncrement(NCFail):
    pass

Expand

⌄

Focus on logic, not low-level bugs

Nano Contracts run directly in the Python Virtual Machine, a proven runtime trusted by millions of systems, benefiting from years of security hardening and performance optimization.

In May 2025, Cetus Protocol was exploited for $223M using an integer overflow bug. That can’t happen here.

OTHERS DREAM, HATHOR DELIVERS

MEV? Never heard of it

Hathor prevents front-running, sandwich attacks and transaction reordering at the protocol level.

Every contract. Every swap. MEV-proof by default.

Read more

Read more

Read more

Randomness, Solved

Real randomness. On-chain. No oracles.

Most networks rely on external oracles to generate randomness, introducing extra complexity, latency, potential trust issues, and costs. Hathor provides built-in on-chain randomness directly to Nano Contracts.

Perfect for games, NFTs, lotteries and more.

Code once. Deploy forever.

Nano Contracts separate logic (blueprints) from state (contract instances).

Think of blueprints as Python classes: reusable, auditable templates that anyone can instantiate. Benefits:

  • Reuse proven logic

  • Build faster from trusted components

  • Easier audits

Developer Royalties

Every time someone uses your blueprint, you earn a cut of the fees. That means your code keeps paying you back, like on-chain royalties for developers.

Code once. Earn forever.

Read more

Read more

Read more