Urbit Docs
  • What is Urbit?
  • Get on Urbit
  • Build on Urbit
    • Contents
    • Environment Setup
    • Hoon School
      • 1. Hoon Syntax
      • 2. Azimuth (Urbit ID)
      • 3. Gates (Functions)
      • 4. Molds (Types)
      • 5. Cores
      • 6. Trees and Addressing
      • 7. Libraries
      • 8. Testing Code
      • 9. Text Processing I
      • 10. Cores and Doors
      • 11. Data Structures
      • 12. Type Checking
      • 13. Conditional Logic
      • 14. Subject-Oriented Programming
      • 15. Text Processing II
      • 16. Functional Programming
      • 17. Text Processing III
      • 18. Generic and Variant Cores
      • 19. Mathematics
    • App School I
      • 1. Arvo
      • 2. The Agent Core
      • 3. Imports and Aliases
      • 4. Lifecycle
      • 5. Cards
      • 6. Pokes
      • 7. Structures and Marks
      • 8. Subscriptions
      • 9. Vanes
      • 10. Scries
      • 11. Failure
      • 12. Next Steps
      • Appendix: Types
    • App School II (Full-Stack)
      • 1. Types
      • 2. Agent
      • 3. JSON
      • 4. Marks
      • 5. Eyre
      • 6. React app setup
      • 7. React app logic
      • 8. Desk and glob
      • 9. Summary
    • Core Academy
      • 1. Evaluating Nock
      • 2. Building Hoon
      • 3. The Core Stack
      • 4. Arvo I: The Main Sequence
      • 5. Arvo II: The Boot Sequence
      • 6. Vere I: u3 and the Serf
      • 7. Vere II: The Loom
      • 8. Vanes I: Behn, Dill, Kahn, Lick
      • 9. Vanes II: Ames
      • 10. Vanes III: Eyre, Iris
      • 11. Vanes IV: Clay
      • 12. Vanes V: Gall and Userspace
      • 13. Vanes VI: Khan, Lick
      • 14. Vanes VII: Jael, Azimuth
    • Runtime
      • U3
      • Conn.c Guide
      • How to Write a Jet
      • API Overview by Prefix
      • C in Urbit
      • Cryptography
      • Land of Nouns
    • Tools
      • Useful Links
      • JS Libraries
        • HTTP API
      • Docs App
        • File Format
        • Index File
        • Suggested Structure
    • Userspace
      • Command-Line App Tutorial
      • Remote Scry
      • Unit Tests
      • Software Distribution
        • Software Distribution Guide
        • Docket File
        • Glob
      • Examples
        • Building a CLI App
        • Debugging Wrapper
        • Host a Website
        • Serving a JS Game
        • Ship Monitoring
        • Styled Text
  • Urbit ID
    • What is Urbit ID?
    • Azimuth Data Flow
    • Life and Rift
    • Urbit HD Wallet
    • Advanced Azimuth Tools
    • Custom Roller Tutorial
    • Azimuth.eth Reference
    • Ecliptic.eth Reference
    • Layer 2
      • L2 Actions
      • L2 Rollers
      • L2 Roller HTTP RPC-API
      • L2 Transaction Format
  • Urbit OS
    • What is Urbit OS?
    • Base
      • Hood
      • Threads
        • Basics Tutorial
          • Bind
          • Fundamentals
          • Input
          • Output
          • Summary
        • HTTP API Guide
        • Spider API Reference
        • Strandio Reference
        • Examples
          • Child Thread
          • Fetch JSON
          • Gall
            • Poke Thread
            • Start Thread
            • Stop Thread
            • Take Facts
            • Take Result
          • Main-loop
          • Poke Agent
          • Scry
          • Take Fact
    • Kernel
      • Arvo
        • Cryptography
        • Move Trace
        • Scries
        • Subscriptions
      • Ames
        • Ames API Reference
        • Ames Cryptography
        • Ames Data Types
        • Ames Scry Reference
      • Behn
        • Behn API Reference
        • Behn Examples
        • Behn Scry Reference
      • Clay
        • Clay API Reference
        • Clay Architecture
        • Clay Data Types
        • Clay Examples
        • Clay Scry Reference
        • Filesystem Hierarchy
        • Marks
          • Mark Examples
          • Using Marks
          • Writing Marks
        • Using Clay
      • Dill
        • Dill API Reference
        • Dill Data Types
        • Dill Scry Reference
      • Eyre
        • EAuth
        • Eyre Data Types
        • Eyre External API
        • Eyre Internal API
        • Eyre Scry Reference
        • Low-Level Eyre Guide
        • Noun channels
      • Gall
        • Gall API Reference
        • Gall Data Types
        • Gall Scry Reference
      • Iris
        • Iris API Reference
        • Iris Data Types
        • Iris Example
      • Jael
        • Jael API Reference
        • Jael Data Types
        • Jael Examples
        • Jael Scry Reference
      • Khan
        • Khan API Reference
        • Khan Data Types
        • Khan Example
      • Lick
        • Lick API Reference
        • Lick Guide
        • Lick Examples
        • Lick Scry Reference
  • Hoon
    • Why Hoon?
    • Advanced Types
    • Arvo
    • Auras
    • Basic Types
    • Cheat Sheet
    • Cryptography
    • Examples
      • ABC Blocks
      • Competitive Programming
      • Emirp
      • Gleichniszahlenreihe
      • Islands
      • Luhn Number
      • Minimum Path Sum
      • Phone Letters
      • Restore IP
      • Rhonda Numbers
      • Roman Numerals
      • Solitaire Cipher
      • Water Towers
    • Generators
    • Hoon Errors
    • Hoon Style Guide
    • Implementing an Aura
    • Irregular forms
    • JSON
    • Limbs and wings
      • Limbs
      • Wings
    • Mips (Maps of Maps)
    • Parsing Text
    • Runes
      • | bar · Cores
      • $ buc · Structures
      • % cen · Calls
      • : col · Cells
      • . dot · Nock
      • / fas · Imports
      • ^ ket · Casts
      • + lus · Arms
      • ; mic · Make
      • ~ sig · Hints
      • = tis · Subject
      • ? wut · Conditionals
      • ! zap · Wild
      • Constants (Atoms and Strings)
      • --, == · Terminators
    • Sail (HTML)
    • Serialization
    • Sets
    • Standard Library
      • 1a: Basic Arithmetic
      • 1b: Tree Addressing
      • 1c: Molds and Mold-Builders
      • 2a: Unit Logic
      • 2b: List Logic
      • 2c: Bit Arithmetic
      • 2d: Bit Logic
      • 2e: Insecure Hashing
      • 2f: Noun Ordering
      • 2g: Unsigned Powers
      • 2h: Set Logic
      • 2i: Map Logic
      • 2j: Jar and Jug Logic
      • 2k: Queue Logic
      • 2l: Container from Container
      • 2m: Container from Noun
      • 2n: Functional Hacks
      • 2o: Normalizing Containers
      • 2p: Serialization
      • 2q: Molds and Mold-Builders
      • 3a: Modular and Signed Ints
      • 3b: Floating Point
      • 3c: Urbit Time
      • 3d: SHA Hash Family
      • 3e: AES encryption (Removed)
      • 3f: Scrambling
      • 3g: Molds and Mold-Builders
      • 4a: Exotic Bases
      • 4b: Text Processing
      • 4c: Tank Printer
      • 4d: Parsing (Tracing)
      • 4e: Parsing (Combinators)
      • 4f: Parsing (Rule-Builders)
      • 4g: Parsing (Outside Caller)
      • 4h: Parsing (ASCII Glyphs)
      • 4i: Parsing (Useful Idioms)
      • 4j: Parsing (Bases and Base Digits)
      • 4k: Atom Printing
      • 4l: Atom Parsing
      • 4m: Formatting Functions
      • 4n: Virtualization
      • 4o: Molds
      • 5a: Compiler Utilities
      • 5b: Macro Expansion
      • 5c: Compiler Backend & Prettyprinter
      • 5d: Parser
      • 5e: Molds and mold builders
      • 5f: Profiling support
    • Strings
    • The Engine Pattern
    • Udon (Markdown-esque)
    • Vases
    • Zuse
      • 2d(1-5): To JSON, Wains
      • 2d(6): From JSON
      • 2d(7): From JSON (unit)
      • 2e(2-3): Print & Parse JSON
      • 2m: Ordered Maps
  • Nock
    • What is Nock?
    • Decrement
    • Definition
    • Fast Hints and Jets
    • Implementations
    • Specification
  • User Manual
    • Contents
    • Running Urbit
      • Cloud Hosting
      • Home Servers
      • Runtime Reference
      • Self-hosting S3 Storage with MinIO
    • Urbit ID
      • Bridge Troubleshooting
      • Creating an Invite Pool
      • Get an Urbit ID
      • Guide to Factory Resets
      • HD Wallet (Master Ticket)
      • Layer 2 for planets
      • Layer 2 for stars
      • Proxies
      • Using Bridge
    • Urbit OS
      • Basics
      • Configuring S3 Storage
      • Dojo Tools
      • Filesystem
      • Shell
      • Ship Troubleshooting
      • Star and Galaxy Operations
      • Updates
Powered by GitBook

GitHub

  • Urbit ID
  • Urbit OS
  • Runtime

Resources

  • YouTube
  • Whitepaper
  • Awesome Urbit

Contact

  • X
  • Email
  • Gather
On this page
  • Network topology
  • Smart contracts
  • General Azimuth Resources
  • Naive rollups
Edit on GitHub
  1. Urbit ID

What is Urbit ID?

Urbit ID is Urbit's identity standard. It's decentralized, secure, and human-meaningful. It's basis is a public-key infrastructure (PKI) implemented with NFTs on the Ethereum blockchain.

You need an Urbit ID to get on the Urbit network. Your Urbit ID allows your Urbit OS server to cryptographically sign every message it sends over the network: everything you see on Urbit really comes from who it says it does.

Network topology

Like any peer-to-peer network, Urbit needs topographic affordances for bootstrapping peer discovery. Some notions of governance, ownership, and reputation are nice-to-haves. Urbit solves these issues by dividing the address space into five "ranks":

  • Galaxies: These 2^8 (256) nodes make up Urbit's Galactic Senate, which ratifies governance proposals and votes on smart contract upgrades. The Senate also elects the Board of Directors of the Urbit Foundation. They spawn and sponsor stars.

  • Stars: These 2^16 (65,536) nodes distribute software updates to their sponsees. Eventually they may be used for peer discovery. They spawn and sponsor planets.

  • Planets: There are 2^32 (~4 billion) nodes are for day-to-day individual usage. They spawn and sponsor moons.

  • Moons: Every planet can spawn ~4 billion moons, which are ideal for identifying machines tied to their owner's planet. Today, these are mostly used by app developers to host software distribution nodes on cloud servers.

  • Comets: Urbit ID also has room for 2^64 (~18 quintillion) free, anonymous, disposable identities. They aren't sponsored and don't interact with the blockchain at all.

Technically, "sponsorship" just means that the sponsor is responsible for distributing software updates to the sponsee. Whether this sponsorship chain means that one node endorses another as trustworthy is totally implicit.

Smart contracts

Urbit ID ownership is stored on a smart contract at azimuth.eth, and that store is goverend by a contract at ecliptic.eth. Other contracts provide supplementary functionality.

You can read these contracts on Etherscan:

  • Azimuth.eth 0x223c067f8cf28ae173ee5cafea60ca44c335fecb: Contains all on-chain state for Urbit ID. Most notably, ownership and public keys. Can't be modified directly, you must use Ecliptic.

  • Ecliptic.eth 0x33EeCbf908478C10614626A9D304bfe18B78DD73: An interface for interacting with Azimuth. Allows you to configure keys, transfer ownership, etc.

  • Polls 0x7fecab617c868bb5996d99d95200d2fa708218e4: Registers votes on governance proposals by Urbit's Galactic Senate. These can be either static documents or Ecliptic upgrades.

  • Linear Star Release 0x86cd9cd0992f04231751e3761de45cecea5d1801: Facilitates the release of blocks of stars to their owners over a period of time.

  • Conditional Star Release 0x8c241098c3d3498fe1261421633fd57986d74aea: Facilitates the release of blocks of stars to their owners based on milestones.

  • Claims 0xe7e7f69b34d7d9bd8d61fb22c33b22708947971a: Allows point owners to make claims about (for example) their identity, and associate that with their point.

  • Censures 0x325f68d32bdee6ed86e7235ff2480e2a433d6189: Simple reputation management, allowing galaxies and stars to flag points for negative reputation.

  • Delegated Sending 0xf6b461fe1ad4bd2ce25b23fe0aff2ac19b3dfa76: Enables network-effect like distributing of planets.

General Azimuth Resources

These documents pertain to L1 and other general aspects of Azimuth. For L2 docs, see below.

  • HD Wallet - Azimuth has its own optional hierarchical deterministic wallet system, often referred to as a "master ticket".

  • Data Flow - Diagrams and explanations of how data flows between Bridge and the various components inside Urbit involved with Azimuth and L2.

  • Azimuth.eth - A description of the azimuth.eth smart contract, which is the data store for Azimuth.

  • Ecliptic.eth - A description of the ecliptic.eth smart contract, which is the business logic for azimuth.eth. This includes an overview of all function calls available.

  • Advanced Azimuth Tools - Expert-level tooling for generating, signing, and sending layer 1 Azimuth transactions from within Urbit itself.

  • Life and Rift - An explanation of how Azimuth indexes networking keys revisions and breaches to keep track of the most recent set of networking keys necessary to communicate with a ship.

Naive rollups

In 2021, Tlon introduced a new component to Azimuth called naive rollups, and often referred to as Urbit ID's "Layer 2" or "L2". It was intended to reduce gas costs for working with Urbit ID and the friction associated with using cryptocurrency in general. This system allows batches of transactions with azimuth.eth to be submitted together as a single transaction, using an Urbit node known as a "roller". The PKI state transitions resulting from these transactions are computed locally by your urbit rather than by the Ethereum Virtual Machine.

Due to the extremely low cost, Tlon offers their own roller that is free for ordinary public use. This enables new users to get started with a permanent Urbit ID without any prior knowledge of Ethereum, cryptocurrency, or blockchains. Anybody can run a roller, and you can even use your own ship as a roller to submit single transactions.

Layer 2 resources

  • Layer 2 Overview - An overview of how naive rollups work.

  • Custom Roller Tutorial - A guide to running your own L2 roller locally.

  • Actions Reference - Details of the L2 API's possible actions.

  • Transaction Format Reference - Details of the bytestring format for L2 transactions and batches.

  • Roller - Overview of the L2 roller system.

PreviousStyled TextNextAzimuth Data Flow

Last updated 1 day ago