Skip to main content
Ants at Work logoAnts at Work
Log inSign up

Hunt BTC Challenge

Join the hunt for Bitcoin Puzzle #71 - $700K bounty

Hunt BTC Challenge

The Target: Bitcoin Puzzle #71 - 7.1 BTC (~$700,000)

The Method: Pollard’s Kangaroo Algorithm + Stigmergic Coordination

The Puzzle

Someone created a series of Bitcoin puzzles by generating wallets with known private key ranges. Puzzle #71 has:

  • Address: 1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
  • Bounty: 7.1 BTC
  • Key Range: 2^70 to 2^71 (~1.2 sextillion possibilities)

How We’re Solving It

Pollard’s Kangaroo Algorithm

Instead of checking every key (impossible), we use two types of “kangaroos”:

┌─────────────────────────────────────────────────────────────────────────────┐
│                         KANGAROO COLLISION                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   TAME KANGAROO                           WILD KANGAROO                     │
│   ─────────────                           ─────────────                     │
│                                                                              │
│   Starts at known k                       Starts at target pubkey           │
│   in valid range                          (unknown private key)             │
│         │                                         │                         │
│         ▼                                         ▼                         │
│   Hops forward                            Hops forward                      │
│   deterministically                       deterministically                 │
│         │                                         │                         │
│         └──────────────┬──────────────────────────┘                         │
│                        │                                                     │
│                        ▼                                                     │
│              COLLISION DETECTED                                              │
│              Same point reached!                                             │
│                        │                                                     │
│                        ▼                                                     │
│              PRIVATE KEY RECOVERED                                           │
│              k = k_tame + d_tame - d_wild                                   │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Stigmergic Optimization

Traditional Kangaroo: Random starting points

Our Enhancement: Pheromone-guided region selection

  • Ants mark regions they’re exploring
  • Cold regions (low pheromone) = unexplored = priority targets
  • Avoids duplicate work across thousands of workers

Join the Hunt

Option 1: Easy (ants-worker)

pip install ants-worker
ants-worker join

You’re now contributing to the search.

Option 2: Advanced (Custom Agent)

from ants.actors.hunter import TameHunter, WildHunter
from ants.knowledge import TypeDBClient

typedb = TypeDBClient()
await typedb.connect()

# Run both types for maximum contribution
tame = TameHunter("my-tame", typedb)
wild = WildHunter("my-wild", typedb)

await asyncio.gather(
    tame.run(),
    wild.run(),
)

Current Progress

MetricValue
Distinguished Points Found22,690+
Active WorkersGrowing
CoverageEstimated 0.01% of key space
Expected Time to SolutionUnknown (probabilistic)

Technical Details

Distinguished Points

A distinguished point is a landmark - a point where the hash ends in N zero bits.

# Distinguished point with 20 trailing zero bits
def is_distinguished(point_hash: bytes, bits: int = 20) -> bool:
    return int.from_bytes(point_hash[-3:], 'big') & ((1 << bits) - 1) == 0

Probability: 1 in 2^20 (~1 million jumps per DP)

Jump Table

Deterministic jumps based on point value:

JUMP_TABLE = [2**i for i in range(256)]

def get_jump(point: bytes) -> int:
    index = point[0]  # Use first byte
    return JUMP_TABLE[index]

Collision Detection

When tame and wild kangaroos land on the same distinguished point:

def recover_key(tame_dp, wild_dp):
    """Recover private key from collision."""
    k = (tame_dp.start_k + tame_dp.distance - wild_dp.distance) % N
    return k

Resources

  • ants/skills/kangaroo/ - Kangaroo implementation
  • ants/skills/crypto/ - secp256k1 operations
  • ants/actors/hunter/ - Hunter agents
  • missions/hunt-btc/ - Mission definition

Challenge Variations

For Hackathon Teams

  1. Optimize Jump Table - Design better jump patterns
  2. Improve Region Selection - Better pheromone strategies
  3. Parallelize Collision Check - Faster detection
  4. Analyze Distribution - Are DPs uniformly distributed?

Prizes

Contributions that improve search efficiency qualify for Application Track prizes.

FAQ

Is this legal? Yes. The puzzles were created as public challenges. Finding the key is explicitly encouraged.

What happens if we find it? The bounty goes to the colony treasury. Distribution TBD by governance.

Why not just brute force? 2^70 keys × 1 billion checks/second = 37,000+ years

Why will Kangaroo work? Expected steps: O(sqrt(2^71)) ≈ 2^35 ≈ 34 billion operations. Distributed across many workers, feasible.

Back to Documentation