diff --git a/Cargo.toml b/Cargo.toml
index a2a897062d..6740afb3ef 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ord"
-description = "Bitcoin satoshi ordinal number utility"
+description = "Bitcoin ordinal theory utility"
 version = "0.2.1"
 license = "CC0-1.0"
 edition = "2021"
diff --git a/README.md b/README.md
index 184e106d8e..04354a3cb4 100644
--- a/README.md
+++ b/README.md
@@ -3,8 +3,11 @@
 
 `ord` is an index, block explorer, and command-line wallet.
 
-Ordinals are serial numbers for satoshis, assigned in the order in which they
-are mined, and preserved across transactions.
+Ordinal theory imbues satoshis with numismatic value, allowing them to
+collected and traded as curios.
+
+Ordinal numbers are serial numbers for satoshis, assigned in the order in which
+they are mined, and preserved across transactions.
 
 See [the BIP](bip.mediawiki) for a comprehensive description of the assignment
 and transfer algorithm.
@@ -38,7 +41,7 @@ Syncing
 -------
 
 `ord` requires a synced `bitcoind` node with `-txindex` to build the index of
-ordinal locations. `ord` communicates with `bitcoind` via RPC.
+satoshi locations. `ord` communicates with `bitcoind` via RPC.
 
 If `bitcoind` is run locally by the same user, without additional
 configuration, `ord` should find it automatically by reading the `.cookie` file
diff --git a/ROADMAP.md b/ROADMAP.md
deleted file mode 100644
index b31bd61f4a..0000000000
--- a/ROADMAP.md
+++ /dev/null
@@ -1,36 +0,0 @@
-Ordinals Roadmap
-================
-
-Features
---------
-
-- Collecting and Trading
-  - [x] Users can list rare ordinals in their UTXOs
-  - [x] Users can send and receive specific ordinals
-  - [ ] Users can buy and sell ordinals P2P in a Discord channel
-  - [ ] Users can buy and sell ordinals via a trusted OTC desk
-  - [ ] Users can buy and sell ordinals using trustless offers
-  - [ ] Trustless offers can be viewed on ord block explorers
-
-- NFTs MVP
-  - [ ] Users can mint NFTs
-  - [ ] Users can view NFTs locally
-  - [ ] Users can view NFTs on ord block explorers
-  - [ ] Users can send and receive NFTs
-
-Community
----------
-
-- memes
-- twitter bot
-- blog about ordinals
-- keep doing bounties
-- request a bip
-- create a market for ordinals
-
-Development
------------
-
-- onboard new contributors
-- keep streaming on Twitter Spaces & Discord
-- make development easy and fast
diff --git a/bin/graph b/bin/graph
index 7ca36919d1..2a1ce35e5b 100755
--- a/bin/graph
+++ b/bin/graph
@@ -13,7 +13,7 @@ class Block:
 
 pat = re.compile(
   '''Block (?P<height>[0-9]+) at.*with (?P<transactions>[0-9]+) transactions.*
-.*Wrote (?P<ranges>[0-9]+) ordinal ranges from .* outputs in (?P<time>[0-9]+) ms'''
+.*Wrote (?P<ranges>[0-9]+) sat ranges from .* outputs in (?P<time>[0-9]+) ms'''
 )
 
 blocks = [
diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
index 6cf65c926b..cf04456e14 100644
--- a/docs/src/SUMMARY.md
+++ b/docs/src/SUMMARY.md
@@ -6,7 +6,7 @@
 - [Guides](guides.md)
   - [Explorer](guides/explorer.md)
   - [Inscriptions](guides/inscriptions.md)
-  - [Ordinal Hunting](guides/ordinal-hunting.md)
+  - [Sat Hunting](guides/sat-hunting.md)
 - [Bounties](bounties.md)
   - [Bounty 0: 100,000 sats Claimed!](bounty/0.md)
   - [Bounty 1: 200,000 sats Claimed!](bounty/1.md)
diff --git a/docs/src/bounties.md b/docs/src/bounties.md
index 2dbc2093e3..e3c5d4fc17 100644
--- a/docs/src/bounties.md
+++ b/docs/src/bounties.md
@@ -5,14 +5,15 @@ Ordinal Bounty Hunting Hints
   ordinal theory is extremely simple. A clever hacker should be able to write
   code from scratch to manipulate satoshis using ordinal theory in no time.
 
-- For more information about ordinals, check out the [FAQ](./faq.md) for an
-  overview, the [BIP](https://github.com/casey/ord/blob/master/bip.mediawiki)
-  for the technical details, and the [ord repo](https://github.com/casey/ord)
-  for the `ord` wallet and block explorer.
+- For more information about ordinal theory, check out the [FAQ](./faq.md) for
+  an overview, the
+  [BIP](https://github.com/casey/ord/blob/master/bip.mediawiki) for the
+  technical details, and the [ord repo](https://github.com/casey/ord) for the
+  `ord` wallet and block explorer.
 
 - Satoshi was the original developer of ordinal theory. However, he knew that
   others would consider it heretical and dangerous, so he hid his knowledge,
   and it was lost to the sands of time. This potent theory is only now being
-  rediscovered. You can help by researching rare ordinals.
+  rediscovered. You can help by researching rare satoshis.
 
 Good luck and godspeed!
diff --git a/docs/src/bounty/0.md b/docs/src/bounty/0.md
index 1b4ac95d7b..f92f16a458 100644
--- a/docs/src/bounty/0.md
+++ b/docs/src/bounty/0.md
@@ -4,13 +4,13 @@ Ordinal Bounty 0
 Criteria
 --------
 
-Send an ordinal whose number ends with a zero to the submission address:
+Send a sat whose ordinal number ends with a zero to the submission address:
 
 ✅: [1857578125803250](https://ordinals.com/ordinal/1857578125803250)
 
 ❌: [1857578125803251](https://ordinals.com/ordinal/1857578125803251)
 
-The ordinal must be the first ordinal of the output you send.
+The sat must be the first sat of the output you send.
 
 Reward
 ------
diff --git a/docs/src/bounty/1.md b/docs/src/bounty/1.md
index 9373abc2dd..2e4dcb2083 100644
--- a/docs/src/bounty/1.md
+++ b/docs/src/bounty/1.md
@@ -4,8 +4,8 @@ Ordinal Bounty 1
 Criteria
 --------
 
-The transaction that submits a UTXO containing the oldest ordinal, i.e., that
-with the lowest number, amongst all submitted UTXOs will be judged the winner.
+The transaction that submits a UTXO containing the oldest sat, i.e., that with
+the lowest number, amongst all submitted UTXOs will be judged the winner.
 
 The bounty is open for submissions until block 753984—the first block of
 difficulty adjustment period 374. Submissions included in block 753984 or later
diff --git a/docs/src/bounty/2.md b/docs/src/bounty/2.md
index db2ed076cc..4a70457cf4 100644
--- a/docs/src/bounty/2.md
+++ b/docs/src/bounty/2.md
@@ -4,11 +4,11 @@ Ordinal Bounty 2
 Criteria
 --------
 
-Send an <span class=uncommon>uncommon</span> ordinal to the submission address:
+Send an <span class=uncommon>uncommon</span> sat to the submission address:
 
-✅: [347100000000000](https://ordinals.com/ordinal/347100000000000)
+✅: [347100000000000](https://ordinals.com/sat/347100000000000)
 
-❌: [6685000001337](https://ordinals.com/ordinal/6685000001337)
+❌: [6685000001337](https://ordinals.com/sat/6685000001337)
 
 Confirm that the submission address has not received transactions before submitting your entry. Only the first successful submission will be rewarded.
 
diff --git a/docs/src/bounty/3.md b/docs/src/bounty/3.md
index 0bbe8defe3..e98d01874b 100644
--- a/docs/src/bounty/3.md
+++ b/docs/src/bounty/3.md
@@ -8,8 +8,8 @@ Ordinal bounty 3 has two parts, both of which are based on *ordinal names*.
 Ordinal names are a modified base-26 encoding of ordinal numbers. To avoid
 locking short names inside the unspendable genesis block coinbase reward,
 ordinal names get *shorter* as the ordinal number gets *longer*. The name of
-ordinal 0, the first ordinal to be mined is `nvtdijuwxlp` and the name of
-ordinal 2,099,999,997,689,999, the last ordinal to be mined, is `a`.
+sat 0, the first sat to be mined is `nvtdijuwxlp` and the name of sat
+2,099,999,997,689,999, the last sat to be mined, is `a`.
 
 The bounty is open for submissions until block 840000—the first block after the
 fourth halvening. Submissions included in block 840000 or later will not be
@@ -18,9 +18,8 @@ considered.
 Both parts use [frequency.tsv](frequency.tsv), a list of words and the number
 of times they occur in the [Google Books Ngram
 dataset](http://storage.googleapis.com/books/ngrams/books/datasetsv2.html).
-filtered to only include the names of ordinals which will have been mined by
-the end of the submission period, that appear at least 5000 times in the
-corpus.
+filtered to only include the names of sats which will have been mined by the
+end of the submission period, that appear at least 5000 times in the corpus.
 
 `frequency.tsv` is a file of tab-separated values. The first column is the
 word, and the second is the number of times it appears in the corpus. The
@@ -30,8 +29,8 @@ occurring.
 `frequency.tsv` was compiled using [this
 program](https://github.com/casey/onegrams).
 
-To search an ordinal wallet for ordinals with a name in `frequency.tsv`, use
-the following [`ord`](https://github.com/casey/ord) command:
+To search an `ord` wallet for sats with a name in `frequency.tsv`, use the
+following [`ord`](https://github.com/casey/ord) command:
 
 ```
 ord wallet satoshis --tsv frequency.tsv
@@ -41,7 +40,7 @@ ord wallet satoshis --tsv frequency.tsv
 
 *Rare sats pair best with rare words.*
 
-The transaction that submits the UTXO containing the ordinal whose name appears
+The transaction that submits the UTXO containing the sat whose name appears
 with the lowest number of occurrences in `frequency.tsv` shall be the winner of
 part 0.
 
@@ -49,7 +48,7 @@ part 0.
 
 *Popularity is the font of value.*
 
-The transaction that submits the UTXO containing the ordinal whose name appears
+The transaction that submits the UTXO containing the sat whose name appears
 with the highest number of occurrences in `frequency.tsv` shall be the winner
 of part 1.
 
diff --git a/docs/src/faq.md b/docs/src/faq.md
index a66379ef84..e1b6d24380 100644
--- a/docs/src/faq.md
+++ b/docs/src/faq.md
@@ -31,7 +31,7 @@ artifacts.
 How does ordinal theory work?
 -----------------------------
 
-Ordinal number are assigned to satoshis in the ordinal in which they are mined.
+Ordinal numbers are assigned to satoshis in the order in which they are mined.
 The first satoshi in the first block has ordinal number 0, the second has
 ordinal number 1, and the last satoshi of the first block has ordinal number
 4,999,999,999.
@@ -91,8 +91,8 @@ Where can I find the nitty-gritty details?
 
 [The BIP!](https://github.com/casey/ord/blob/master/bip.mediawiki)
 
-Why are ordinal inscriptions called "digital artifacts" instead of "NFTs"?
---------------------------------------------------------------------------
+Why are sat inscriptions called "digital artifacts" instead of "NFTs"?
+----------------------------------------------------------------------
 
 An inscription is an NFT, but the term "digital artifact" is used instead,
 because it's simple, suggestive, and familiar.
@@ -105,8 +105,8 @@ Additionally, "NFT" feels like financial terminology, and the both word
 "fungible" and sense of the word "token" as used in "NFT" is uncommon outside
 of financial contexts.
 
-How do ordinal inscriptions compare to…
----------------------------------------
+How do sat inscriptions compare to…
+-----------------------------------
 
 ### Ethereum NFTs?
 
diff --git a/docs/src/guides.md b/docs/src/guides.md
index 42b237ecae..c2538cff8b 100644
--- a/docs/src/guides.md
+++ b/docs/src/guides.md
@@ -2,4 +2,4 @@ Ordinal Theory Guides
 =====================
 
 See the the table of contents for a list of guides, including a guide to the
-explorer, a guide for ordinal hunters, and a guide to inscriptions.
+explorer, a guide for sat hunters, and a guide to inscriptions.
diff --git a/docs/src/guides/explorer.md b/docs/src/guides/explorer.md
index 8899cdf001..311390aac0 100644
--- a/docs/src/guides/explorer.md
+++ b/docs/src/guides/explorer.md
@@ -30,9 +30,9 @@ the genesis block coinbase transaction:
 
 [4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b:0](https://ordinals.com/search/4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b:0)
 
-### Ordinal
+### Sats
 
-Ordinals can be searched by integer, their position within the entire bitcoin
+Sats can be searched by integer, their position within the entire bitcoin
 supply:
 
 [2099994106992659](https://ordinals.com/search/2099994106992659)
diff --git a/docs/src/guides/ordinal-hunting.md b/docs/src/guides/sat-hunting.md
similarity index 100%
rename from docs/src/guides/ordinal-hunting.md
rename to docs/src/guides/sat-hunting.md
diff --git a/docs/src/overview.md b/docs/src/overview.md
index cc169cc1a9..a9d8e6d9e1 100644
--- a/docs/src/overview.md
+++ b/docs/src/overview.md
@@ -13,30 +13,30 @@ name, *ordinals*.
 Technical details are available in [the
 BIP](https://github.com/casey/ord/blob/master/bip.mediawiki).
 
-Ordinals do not require a separate token, another blockchain, or any changes to
-Bitcoin. They work right now.
+Ordinal theory does not require a separate token, another blockchain, or any
+changes to Bitcoin. It works right now.
 
 Ordinal numbers have a few different representations:
 
 - *Integer notation*:
-  [`2099994106992659`](https://ordinals.com/ordinal/2099994106992659) The
+  [`2099994106992659`](https://ordinals.com/sat/2099994106992659) The
   ordinal number, assigned according to the order in which the satoshi was
   mined.
 
 - *Decimal notation*:
-  [`3891094.16797`](https://ordinals.com/ordinal/3891094.16797) The first
+  [`3891094.16797`](https://ordinals.com/sat/3891094.16797) The first
   number is the block height in which the satoshi was mined, the second the
   offset of the satoshi within the block.
 
 - *Degree notation*:
-  [`3°111094′214″16797‴`](https://ordinals.com/ordinal/3%C2%B0111094%E2%80%B2214%E2%80%B316797%E2%80%B4).
+  [`3°111094′214″16797‴`](https://ordinals.com/sat/3%C2%B0111094%E2%80%B2214%E2%80%B316797%E2%80%B4).
   We'll get to that in a moment.
 
 - *Percentile notation*:
-  [`99.99971949060254%`](https://ordinals.com/ordinal/99.99971949060254%25) .
+  [`99.99971949060254%`](https://ordinals.com/sat/99.99971949060254%25) .
   The satoshi's position in Bitcoin's supply, expressed as a percentage.
 
-- *Name*: [`satoshi`](https://ordinals.com/ordinal/satoshi). An encoding of the
+- *Name*: [`satoshi`](https://ordinals.com/sat/satoshi). An encoding of the
   ordinal number using the characters `a` through `z`.
 
 Arbitrary assets, such as NFTs, security tokens, accounts, or stablecoins can
diff --git a/src/decimal.rs b/src/decimal.rs
index fe502592ce..481ec38bce 100644
--- a/src/decimal.rs
+++ b/src/decimal.rs
@@ -6,11 +6,11 @@ pub(crate) struct Decimal {
   offset: u64,
 }
 
-impl From<Ordinal> for Decimal {
-  fn from(ordinal: Ordinal) -> Self {
+impl From<Sat> for Decimal {
+  fn from(sat: Sat) -> Self {
     Self {
-      height: ordinal.height(),
-      offset: ordinal.third(),
+      height: sat.height(),
+      offset: sat.third(),
     }
   }
 }
@@ -28,21 +28,21 @@ mod tests {
   #[test]
   fn decimal() {
     assert_eq!(
-      Ordinal(0).decimal(),
+      Sat(0).decimal(),
       Decimal {
         height: Height(0),
         offset: 0
       }
     );
     assert_eq!(
-      Ordinal(1).decimal(),
+      Sat(1).decimal(),
       Decimal {
         height: Height(0),
         offset: 1
       }
     );
     assert_eq!(
-      Ordinal(2099999997689999).decimal(),
+      Sat(2099999997689999).decimal(),
       Decimal {
         height: Height(6929999),
         offset: 0
diff --git a/src/degree.rs b/src/degree.rs
index 3a88d0c282..d41d872e59 100644
--- a/src/degree.rs
+++ b/src/degree.rs
@@ -18,14 +18,14 @@ impl Display for Degree {
   }
 }
 
-impl From<Ordinal> for Degree {
-  fn from(ordinal: Ordinal) -> Self {
-    let height = ordinal.height().n();
+impl From<Sat> for Degree {
+  fn from(sat: Sat) -> Self {
+    let height = sat.height().n();
     Degree {
       hour: height / (CYCLE_EPOCHS * SUBSIDY_HALVING_INTERVAL),
       minute: height % SUBSIDY_HALVING_INTERVAL,
       second: height % DIFFCHANGE_INTERVAL,
-      third: ordinal.third(),
+      third: sat.third(),
     }
   }
 }
@@ -34,9 +34,9 @@ impl From<Ordinal> for Degree {
 mod tests {
   use super::*;
 
-  fn case(ordinal: u64, hour: u64, minute: u64, second: u64, third: u64) {
+  fn case(sat: u64, hour: u64, minute: u64, second: u64, third: u64) {
     assert_eq!(
-      Degree::from(Ordinal(ordinal)),
+      Degree::from(Sat(sat)),
       Degree {
         hour,
         minute,
diff --git a/src/epoch.rs b/src/epoch.rs
index 57c4c11918..7918191574 100644
--- a/src/epoch.rs
+++ b/src/epoch.rs
@@ -4,41 +4,41 @@ use super::*;
 pub(crate) struct Epoch(pub(crate) u64);
 
 impl Epoch {
-  pub(crate) const STARTING_ORDINALS: [Ordinal; 34] = [
-    Ordinal(0),
-    Ordinal(1050000000000000),
-    Ordinal(1575000000000000),
-    Ordinal(1837500000000000),
-    Ordinal(1968750000000000),
-    Ordinal(2034375000000000),
-    Ordinal(2067187500000000),
-    Ordinal(2083593750000000),
-    Ordinal(2091796875000000),
-    Ordinal(2095898437500000),
-    Ordinal(2097949218750000),
-    Ordinal(2098974609270000),
-    Ordinal(2099487304530000),
-    Ordinal(2099743652160000),
-    Ordinal(2099871825870000),
-    Ordinal(2099935912620000),
-    Ordinal(2099967955890000),
-    Ordinal(2099983977420000),
-    Ordinal(2099991988080000),
-    Ordinal(2099995993410000),
-    Ordinal(2099997995970000),
-    Ordinal(2099998997250000),
-    Ordinal(2099999497890000),
-    Ordinal(2099999748210000),
-    Ordinal(2099999873370000),
-    Ordinal(2099999935950000),
-    Ordinal(2099999967240000),
-    Ordinal(2099999982780000),
-    Ordinal(2099999990550000),
-    Ordinal(2099999994330000),
-    Ordinal(2099999996220000),
-    Ordinal(2099999997060000),
-    Ordinal(2099999997480000),
-    Ordinal(Ordinal::SUPPLY),
+  pub(crate) const STARTING_SATS: [Sat; 34] = [
+    Sat(0),
+    Sat(1050000000000000),
+    Sat(1575000000000000),
+    Sat(1837500000000000),
+    Sat(1968750000000000),
+    Sat(2034375000000000),
+    Sat(2067187500000000),
+    Sat(2083593750000000),
+    Sat(2091796875000000),
+    Sat(2095898437500000),
+    Sat(2097949218750000),
+    Sat(2098974609270000),
+    Sat(2099487304530000),
+    Sat(2099743652160000),
+    Sat(2099871825870000),
+    Sat(2099935912620000),
+    Sat(2099967955890000),
+    Sat(2099983977420000),
+    Sat(2099991988080000),
+    Sat(2099995993410000),
+    Sat(2099997995970000),
+    Sat(2099998997250000),
+    Sat(2099999497890000),
+    Sat(2099999748210000),
+    Sat(2099999873370000),
+    Sat(2099999935950000),
+    Sat(2099999967240000),
+    Sat(2099999982780000),
+    Sat(2099999990550000),
+    Sat(2099999994330000),
+    Sat(2099999996220000),
+    Sat(2099999997060000),
+    Sat(2099999997480000),
+    Sat(Sat::SUPPLY),
   ];
   pub(crate) const FIRST_POST_SUBSIDY: Epoch = Self(33);
 
@@ -50,10 +50,10 @@ impl Epoch {
     }
   }
 
-  pub(crate) fn starting_ordinal(self) -> Ordinal {
-    *Self::STARTING_ORDINALS
+  pub(crate) fn starting_sat(self) -> Sat {
+    *Self::STARTING_SATS
       .get(usize::try_from(self.0).unwrap())
-      .unwrap_or_else(|| Self::STARTING_ORDINALS.last().unwrap())
+      .unwrap_or_else(|| Self::STARTING_SATS.last().unwrap())
   }
 
   pub(crate) fn starting_height(self) -> Height {
@@ -67,73 +67,73 @@ impl PartialEq<u64> for Epoch {
   }
 }
 
-impl From<Ordinal> for Epoch {
-  fn from(ordinal: Ordinal) -> Self {
-    if ordinal < Self::STARTING_ORDINALS[1] {
+impl From<Sat> for Epoch {
+  fn from(sat: Sat) -> Self {
+    if sat < Self::STARTING_SATS[1] {
       Epoch(0)
-    } else if ordinal < Self::STARTING_ORDINALS[2] {
+    } else if sat < Self::STARTING_SATS[2] {
       Epoch(1)
-    } else if ordinal < Self::STARTING_ORDINALS[3] {
+    } else if sat < Self::STARTING_SATS[3] {
       Epoch(2)
-    } else if ordinal < Self::STARTING_ORDINALS[4] {
+    } else if sat < Self::STARTING_SATS[4] {
       Epoch(3)
-    } else if ordinal < Self::STARTING_ORDINALS[5] {
+    } else if sat < Self::STARTING_SATS[5] {
       Epoch(4)
-    } else if ordinal < Self::STARTING_ORDINALS[6] {
+    } else if sat < Self::STARTING_SATS[6] {
       Epoch(5)
-    } else if ordinal < Self::STARTING_ORDINALS[7] {
+    } else if sat < Self::STARTING_SATS[7] {
       Epoch(6)
-    } else if ordinal < Self::STARTING_ORDINALS[8] {
+    } else if sat < Self::STARTING_SATS[8] {
       Epoch(7)
-    } else if ordinal < Self::STARTING_ORDINALS[9] {
+    } else if sat < Self::STARTING_SATS[9] {
       Epoch(8)
-    } else if ordinal < Self::STARTING_ORDINALS[10] {
+    } else if sat < Self::STARTING_SATS[10] {
       Epoch(9)
-    } else if ordinal < Self::STARTING_ORDINALS[11] {
+    } else if sat < Self::STARTING_SATS[11] {
       Epoch(10)
-    } else if ordinal < Self::STARTING_ORDINALS[12] {
+    } else if sat < Self::STARTING_SATS[12] {
       Epoch(11)
-    } else if ordinal < Self::STARTING_ORDINALS[13] {
+    } else if sat < Self::STARTING_SATS[13] {
       Epoch(12)
-    } else if ordinal < Self::STARTING_ORDINALS[14] {
+    } else if sat < Self::STARTING_SATS[14] {
       Epoch(13)
-    } else if ordinal < Self::STARTING_ORDINALS[15] {
+    } else if sat < Self::STARTING_SATS[15] {
       Epoch(14)
-    } else if ordinal < Self::STARTING_ORDINALS[16] {
+    } else if sat < Self::STARTING_SATS[16] {
       Epoch(15)
-    } else if ordinal < Self::STARTING_ORDINALS[17] {
+    } else if sat < Self::STARTING_SATS[17] {
       Epoch(16)
-    } else if ordinal < Self::STARTING_ORDINALS[18] {
+    } else if sat < Self::STARTING_SATS[18] {
       Epoch(17)
-    } else if ordinal < Self::STARTING_ORDINALS[19] {
+    } else if sat < Self::STARTING_SATS[19] {
       Epoch(18)
-    } else if ordinal < Self::STARTING_ORDINALS[20] {
+    } else if sat < Self::STARTING_SATS[20] {
       Epoch(19)
-    } else if ordinal < Self::STARTING_ORDINALS[21] {
+    } else if sat < Self::STARTING_SATS[21] {
       Epoch(20)
-    } else if ordinal < Self::STARTING_ORDINALS[22] {
+    } else if sat < Self::STARTING_SATS[22] {
       Epoch(21)
-    } else if ordinal < Self::STARTING_ORDINALS[23] {
+    } else if sat < Self::STARTING_SATS[23] {
       Epoch(22)
-    } else if ordinal < Self::STARTING_ORDINALS[24] {
+    } else if sat < Self::STARTING_SATS[24] {
       Epoch(23)
-    } else if ordinal < Self::STARTING_ORDINALS[25] {
+    } else if sat < Self::STARTING_SATS[25] {
       Epoch(24)
-    } else if ordinal < Self::STARTING_ORDINALS[26] {
+    } else if sat < Self::STARTING_SATS[26] {
       Epoch(25)
-    } else if ordinal < Self::STARTING_ORDINALS[27] {
+    } else if sat < Self::STARTING_SATS[27] {
       Epoch(26)
-    } else if ordinal < Self::STARTING_ORDINALS[28] {
+    } else if sat < Self::STARTING_SATS[28] {
       Epoch(27)
-    } else if ordinal < Self::STARTING_ORDINALS[29] {
+    } else if sat < Self::STARTING_SATS[29] {
       Epoch(28)
-    } else if ordinal < Self::STARTING_ORDINALS[30] {
+    } else if sat < Self::STARTING_SATS[30] {
       Epoch(29)
-    } else if ordinal < Self::STARTING_ORDINALS[31] {
+    } else if sat < Self::STARTING_SATS[31] {
       Epoch(30)
-    } else if ordinal < Self::STARTING_ORDINALS[32] {
+    } else if sat < Self::STARTING_SATS[32] {
       Epoch(31)
-    } else if ordinal < Self::STARTING_ORDINALS[33] {
+    } else if sat < Self::STARTING_SATS[33] {
       Epoch(32)
     } else {
       Epoch(33)
@@ -152,33 +152,33 @@ mod tests {
   use super::super::*;
 
   #[test]
-  fn starting_ordinal() {
-    assert_eq!(Epoch(0).starting_ordinal(), 0);
+  fn starting_sat() {
+    assert_eq!(Epoch(0).starting_sat(), 0);
     assert_eq!(
-      Epoch(1).starting_ordinal(),
+      Epoch(1).starting_sat(),
       Epoch(0).subsidy() * SUBSIDY_HALVING_INTERVAL
     );
     assert_eq!(
-      Epoch(2).starting_ordinal(),
+      Epoch(2).starting_sat(),
       (Epoch(0).subsidy() + Epoch(1).subsidy()) * SUBSIDY_HALVING_INTERVAL
     );
-    assert_eq!(Epoch(33).starting_ordinal(), Ordinal(Ordinal::SUPPLY));
-    assert_eq!(Epoch(34).starting_ordinal(), Ordinal(Ordinal::SUPPLY));
+    assert_eq!(Epoch(33).starting_sat(), Sat(Sat::SUPPLY));
+    assert_eq!(Epoch(34).starting_sat(), Sat(Sat::SUPPLY));
   }
 
   #[test]
-  fn starting_ordinals() {
-    let mut ordinal = 0;
+  fn starting_sats() {
+    let mut sat = 0;
 
-    let mut epoch_ordinals = Vec::new();
+    let mut epoch_sats = Vec::new();
 
     for epoch in 0..34 {
-      epoch_ordinals.push(ordinal);
-      ordinal += SUBSIDY_HALVING_INTERVAL * Epoch(epoch).subsidy();
+      epoch_sats.push(sat);
+      sat += SUBSIDY_HALVING_INTERVAL * Epoch(epoch).subsidy();
     }
 
-    assert_eq!(Epoch::STARTING_ORDINALS.as_slice(), epoch_ordinals);
-    assert_eq!(Epoch::STARTING_ORDINALS.len(), 34);
+    assert_eq!(Epoch::STARTING_SATS.as_slice(), epoch_sats);
+    assert_eq!(Epoch::STARTING_SATS.len(), 34);
   }
 
   #[test]
@@ -204,22 +204,22 @@ mod tests {
   }
 
   #[test]
-  fn from_ordinal() {
-    for (epoch, starting_ordinal) in Epoch::STARTING_ORDINALS.into_iter().enumerate() {
+  fn from_sat() {
+    for (epoch, starting_sat) in Epoch::STARTING_SATS.into_iter().enumerate() {
       if epoch > 0 {
         assert_eq!(
-          Epoch::from(Ordinal(starting_ordinal.n() - 1)),
+          Epoch::from(Sat(starting_sat.n() - 1)),
           Epoch(epoch as u64 - 1)
         );
       }
-      assert_eq!(Epoch::from(starting_ordinal), Epoch(epoch as u64));
-      assert_eq!(Epoch::from(starting_ordinal + 1), Epoch(epoch as u64));
+      assert_eq!(Epoch::from(starting_sat), Epoch(epoch as u64));
+      assert_eq!(Epoch::from(starting_sat + 1), Epoch(epoch as u64));
     }
-    assert_eq!(Epoch::from(Ordinal(0)), 0);
-    assert_eq!(Epoch::from(Ordinal(1)), 0);
-    assert_eq!(Epoch::from(Epoch(1).starting_ordinal()), 1);
-    assert_eq!(Epoch::from(Epoch(1).starting_ordinal() + 1), 1);
-    assert_eq!(Epoch::from(Ordinal(u64::max_value())), 33);
+    assert_eq!(Epoch::from(Sat(0)), 0);
+    assert_eq!(Epoch::from(Sat(1)), 0);
+    assert_eq!(Epoch::from(Epoch(1).starting_sat()), 1);
+    assert_eq!(Epoch::from(Epoch(1).starting_sat() + 1), 1);
+    assert_eq!(Epoch::from(Sat(u64::max_value())), 33);
   }
 
   #[test]
diff --git a/src/height.rs b/src/height.rs
index c9cefbc5a2..e2a3e20749 100644
--- a/src/height.rs
+++ b/src/height.rs
@@ -12,11 +12,11 @@ impl Height {
     Epoch::from(self).subsidy()
   }
 
-  pub(crate) fn starting_ordinal(self) -> Ordinal {
+  pub(crate) fn starting_sat(self) -> Sat {
     let epoch = Epoch::from(self);
-    let epoch_starting_ordinal = epoch.starting_ordinal();
+    let epoch_starting_sat = epoch.starting_sat();
     let epoch_starting_height = epoch.starting_height();
-    epoch_starting_ordinal + (self - epoch_starting_height.n()).n() * epoch.subsidy()
+    epoch_starting_sat + (self - epoch_starting_height.n()).n() * epoch.subsidy()
   }
 
   pub(crate) fn period_offset(self) -> u64 {
@@ -90,24 +90,24 @@ mod tests {
   }
 
   #[test]
-  fn starting_ordinal() {
-    assert_eq!(Height(0).starting_ordinal(), 0);
-    assert_eq!(Height(1).starting_ordinal(), 5000000000);
+  fn starting_sat() {
+    assert_eq!(Height(0).starting_sat(), 0);
+    assert_eq!(Height(1).starting_sat(), 5000000000);
     assert_eq!(
-      Height(SUBSIDY_HALVING_INTERVAL - 1).starting_ordinal(),
+      Height(SUBSIDY_HALVING_INTERVAL - 1).starting_sat(),
       (SUBSIDY_HALVING_INTERVAL - 1) * 5000000000
     );
     assert_eq!(
-      Height(SUBSIDY_HALVING_INTERVAL).starting_ordinal(),
+      Height(SUBSIDY_HALVING_INTERVAL).starting_sat(),
       SUBSIDY_HALVING_INTERVAL * 5000000000
     );
     assert_eq!(
-      Height(SUBSIDY_HALVING_INTERVAL + 1).starting_ordinal(),
+      Height(SUBSIDY_HALVING_INTERVAL + 1).starting_sat(),
       SUBSIDY_HALVING_INTERVAL * 5000000000 + 2500000000
     );
     assert_eq!(
-      Height(u64::max_value()).starting_ordinal(),
-      *Epoch::STARTING_ORDINALS.last().unwrap()
+      Height(u64::max_value()).starting_sat(),
+      *Epoch::STARTING_SATS.last().unwrap()
     );
   }
 
diff --git a/src/index.rs b/src/index.rs
index bf214c28f7..88335e4afe 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -15,18 +15,18 @@ mod updater;
 
 type BlockHashArray = [u8; 32];
 type InscriptionIdArray = [u8; 32];
-type OrdinalRangeArray = [u8; 11];
+type SatRangeArray = [u8; 11];
 type OutPointArray = [u8; 36];
 type SatPointArray = [u8; 44];
 
 const HEIGHT_TO_BLOCK_HASH: TableDefinition<u64, &BlockHashArray> =
   TableDefinition::new("HEIGHT_TO_BLOCK_HASH");
-const ORDINAL_TO_INSCRIPTION_ID: TableDefinition<u64, &InscriptionIdArray> =
-  TableDefinition::new("ORDINAL_TO_INSCRIPTION_ID");
-const ORDINAL_TO_SATPOINT: TableDefinition<u64, &SatPointArray> =
-  TableDefinition::new("ORDINAL_TO_SATPOINT");
-const OUTPOINT_TO_ORDINAL_RANGES: TableDefinition<&OutPointArray, [u8]> =
-  TableDefinition::new("OUTPOINT_TO_ORDINAL_RANGES");
+const SAT_TO_INSCRIPTION_ID: TableDefinition<u64, &InscriptionIdArray> =
+  TableDefinition::new("SAT_TO_INSCRIPTION_ID");
+const SAT_TO_SATPOINT: TableDefinition<u64, &SatPointArray> =
+  TableDefinition::new("SAT_TO_SATPOINT");
+const OUTPOINT_TO_SAT_RANGES: TableDefinition<&OutPointArray, [u8]> =
+  TableDefinition::new("OUTPOINT_TO_SAT_RANGES");
 const STATISTIC_TO_COUNT: TableDefinition<u64, u64> = TableDefinition::new("STATISTIC_TO_COUNT");
 const WRITE_TRANSACTION_STARTING_BLOCK_COUNT_TO_TIMESTAMP: TableDefinition<u64, u128> =
   TableDefinition::new("WRITE_TRANSACTION_START_BLOCK_COUNT_TO_TIMESTAMP");
@@ -87,7 +87,7 @@ pub(crate) enum List {
 pub(crate) enum Statistic {
   OutputsTraversed = 0,
   Commits = 1,
-  OrdinalRanges = 2,
+  SatRanges = 2,
 }
 
 impl Statistic {
@@ -110,7 +110,7 @@ pub(crate) struct Info {
   pub(crate) index_file_size: u64,
   pub(crate) leaf_pages: usize,
   pub(crate) metadata_bytes: usize,
-  pub(crate) ordinal_ranges: u64,
+  pub(crate) sat_ranges: u64,
   pub(crate) outputs_traversed: u64,
   pub(crate) page_size: usize,
   pub(crate) stored_bytes: usize,
@@ -204,14 +204,14 @@ impl Index {
 
         tx.open_table(HEIGHT_TO_BLOCK_HASH)?;
         tx.open_table(INSCRIPTION_ID_TO_SATPOINT)?;
-        tx.open_table(ORDINAL_TO_INSCRIPTION_ID)?;
-        tx.open_table(ORDINAL_TO_SATPOINT)?;
+        tx.open_table(SAT_TO_INSCRIPTION_ID)?;
+        tx.open_table(SAT_TO_SATPOINT)?;
         tx.open_table(SATPOINT_TO_INSCRIPTION_ID)?;
         tx.open_table(STATISTIC_TO_COUNT)?;
         tx.open_table(WRITE_TRANSACTION_STARTING_BLOCK_COUNT_TO_TIMESTAMP)?;
 
         if options.index_satoshis {
-          tx.open_table(OUTPOINT_TO_ORDINAL_RANGES)?;
+          tx.open_table(OUTPOINT_TO_SAT_RANGES)?;
         }
 
         tx.commit()?;
@@ -239,7 +239,7 @@ impl Index {
   }
 
   pub(crate) fn has_satoshi_index(&self) -> Result<bool> {
-    match self.begin_read()?.0.open_table(OUTPOINT_TO_ORDINAL_RANGES) {
+    match self.begin_read()?.0.open_table(OUTPOINT_TO_SAT_RANGES) {
       Ok(_) => Ok(true),
       Err(redb::Error::TableDoesNotExist(_)) => Ok(false),
       Err(err) => Err(err.into()),
@@ -274,8 +274,8 @@ impl Index {
         index_file_size: fs::metadata(&self.database_path)?.len(),
         leaf_pages: stats.leaf_pages(),
         metadata_bytes: stats.metadata_bytes(),
-        ordinal_ranges: statistic_to_count
-          .get(&Statistic::OrdinalRanges.key())?
+        sat_ranges: statistic_to_count
+          .get(&Statistic::SatRanges.key())?
           .unwrap_or(0),
         outputs_traversed: statistic_to_count
           .get(&Statistic::OutputsTraversed.key())?
@@ -293,14 +293,14 @@ impl Index {
           )
           .collect(),
         tree_height: stats.tree_height(),
-        utxos_indexed: wtx.open_table(OUTPOINT_TO_ORDINAL_RANGES)?.len()?,
+        utxos_indexed: wtx.open_table(OUTPOINT_TO_SAT_RANGES)?.len()?,
       }
     };
 
     Ok(info)
   }
 
-  pub(crate) fn decode_ordinal_range(bytes: OrdinalRangeArray) -> (u64, u64) {
+  pub(crate) fn decode_sat_range(bytes: SatRangeArray) -> (u64, u64) {
     let raw_base = u64::from_le_bytes([
       bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], 0,
     ]);
@@ -384,16 +384,16 @@ impl Index {
     Ok(blocks)
   }
 
-  pub(crate) fn rare_ordinal_satpoints(&self) -> Result<Option<Vec<(Ordinal, SatPoint)>>> {
+  pub(crate) fn rare_sat_satpoints(&self) -> Result<Option<Vec<(Sat, SatPoint)>>> {
     if self.has_satoshi_index()? {
       let mut result = Vec::new();
 
       let rtx = self.database.begin_read()?;
 
-      let ordinal_to_satpoint = rtx.open_table(ORDINAL_TO_SATPOINT)?;
+      let sat_to_satpoint = rtx.open_table(SAT_TO_SATPOINT)?;
 
-      for (ordinal, satpoint) in ordinal_to_satpoint.range(0..)? {
-        result.push((Ordinal(ordinal), decode_satpoint(*satpoint)));
+      for (sat, satpoint) in sat_to_satpoint.range(0..)? {
+        result.push((Sat(sat), decode_satpoint(*satpoint)));
       }
 
       Ok(Some(result))
@@ -425,11 +425,11 @@ impl Index {
     self.client.get_block(&hash).into_option()
   }
 
-  pub(crate) fn get_inscription_by_ordinal(&self, ordinal: Ordinal) -> Result<Option<Inscription>> {
+  pub(crate) fn get_inscription_by_sat(&self, sat: Sat) -> Result<Option<Inscription>> {
     let db = self.database.begin_read()?;
-    let table = db.open_table(ORDINAL_TO_INSCRIPTION_ID)?;
+    let table = db.open_table(SAT_TO_INSCRIPTION_ID)?;
 
-    let Some(txid) = table.get(&ordinal.n())? else {
+    let Some(txid) = table.get(&sat.n())? else {
       return Ok(None);
     };
 
@@ -483,26 +483,26 @@ impl Index {
     )
   }
 
-  pub(crate) fn find(&self, ordinal: u64) -> Result<Option<SatPoint>> {
+  pub(crate) fn find(&self, sat: u64) -> Result<Option<SatPoint>> {
     self.require_satoshi_index("find")?;
 
     let rtx = self.begin_read()?;
 
-    if rtx.block_count()? <= Ordinal(ordinal).height().n() {
+    if rtx.block_count()? <= Sat(sat).height().n() {
       return Ok(None);
     }
 
-    let outpoint_to_ordinal_ranges = rtx.0.open_table(OUTPOINT_TO_ORDINAL_RANGES)?;
+    let outpoint_to_sat_ranges = rtx.0.open_table(OUTPOINT_TO_SAT_RANGES)?;
 
-    for (key, value) in outpoint_to_ordinal_ranges.range([0; 36]..)? {
+    for (key, value) in outpoint_to_sat_ranges.range([0; 36]..)? {
       let mut offset = 0;
       for chunk in value.chunks_exact(11) {
-        let (start, end) = Index::decode_ordinal_range(chunk.try_into().unwrap());
-        if start <= ordinal && ordinal < end {
+        let (start, end) = Index::decode_sat_range(chunk.try_into().unwrap());
+        if start <= sat && sat < end {
           let outpoint = decode_outpoint(*key);
           return Ok(Some(SatPoint {
             outpoint,
-            offset: offset + ordinal - start,
+            offset: offset + sat - start,
           }));
         }
         offset += end - start;
@@ -517,7 +517,7 @@ impl Index {
       self
         .database
         .begin_read()?
-        .open_table(OUTPOINT_TO_ORDINAL_RANGES)?
+        .open_table(OUTPOINT_TO_SAT_RANGES)?
         .get(&outpoint)?
         .map(|outpoint| outpoint.to_vec()),
     )
@@ -528,13 +528,13 @@ impl Index {
 
     let outpoint_encoded = encode_outpoint(outpoint);
 
-    let ordinal_ranges = self.list_inner(outpoint_encoded)?;
+    let sat_ranges = self.list_inner(outpoint_encoded)?;
 
-    match ordinal_ranges {
-      Some(ordinal_ranges) => Ok(Some(List::Unspent(
-        ordinal_ranges
+    match sat_ranges {
+      Some(sat_ranges) => Ok(Some(List::Unspent(
+        sat_ranges
           .chunks_exact(11)
-          .map(|chunk| Self::decode_ordinal_range(chunk.try_into().unwrap()))
+          .map(|chunk| Self::decode_sat_range(chunk.try_into().unwrap()))
           .collect(),
       ))),
       None => {
@@ -564,7 +564,7 @@ impl Index {
           .unwrap_or(0);
 
         let expected_blocks = height.checked_sub(current).with_context(|| {
-          format!("current {current} height is greater than ordinal height {height}")
+          format!("current {current} height is greater than sat height {height}")
         })?;
 
         Ok(Blocktime::Expected(
@@ -891,7 +891,7 @@ mod tests {
   }
 
   #[test]
-  fn find_first_ordinal() {
+  fn find_first_sat() {
     let context = Context::with_args("--index-satoshis");
     assert_eq!(
       context.index.find(0).unwrap().unwrap(),
@@ -905,7 +905,7 @@ mod tests {
   }
 
   #[test]
-  fn find_second_ordinal() {
+  fn find_second_sat() {
     let context = Context::with_args("--index-satoshis");
     assert_eq!(
       context.index.find(1).unwrap().unwrap(),
@@ -919,7 +919,7 @@ mod tests {
   }
 
   #[test]
-  fn find_first_ordinal_of_second_block() {
+  fn find_first_sat_of_second_block() {
     let context = Context::with_args("--index-satoshis");
     context.rpc_server.mine_blocks(1);
     context.index.update().unwrap();
@@ -935,7 +935,7 @@ mod tests {
   }
 
   #[test]
-  fn find_unmined_ordinal() {
+  fn find_unmined_sat() {
     let context = Context::with_args("--index-satoshis");
     assert_eq!(context.index.find(50 * COIN_VALUE).unwrap(), None);
   }
diff --git a/src/index/updater.rs b/src/index/updater.rs
index d893750550..56995fd621 100644
--- a/src/index/updater.rs
+++ b/src/index/updater.rs
@@ -25,7 +25,7 @@ pub struct Updater {
   cache: HashMap<OutPointArray, Vec<u8>>,
   height: u64,
   index_satoshis: bool,
-  ordinal_ranges_since_flush: u64,
+  sat_ranges_since_flush: u64,
   outputs_cached: u64,
   outputs_inserted_since_flush: u64,
   outputs_traversed: u64,
@@ -57,7 +57,7 @@ impl Updater {
       cache: HashMap::new(),
       height,
       index_satoshis: index.has_satoshi_index()?,
-      ordinal_ranges_since_flush: 0,
+      sat_ranges_since_flush: 0,
       outputs_cached: 0,
       outputs_inserted_since_flush: 0,
       outputs_traversed: 0,
@@ -248,7 +248,7 @@ impl Updater {
     let mut height_to_block_hash = wtx.open_table(HEIGHT_TO_BLOCK_HASH)?;
 
     let start = Instant::now();
-    let mut ordinal_ranges_written = 0;
+    let mut sat_ranges_written = 0;
     let mut outputs_in_block = 0;
 
     let time = Utc.timestamp_opt(block.header.time.into(), 0).unwrap();
@@ -273,69 +273,69 @@ impl Updater {
     let mut satpoint_to_inscription_id = wtx.open_table(SATPOINT_TO_INSCRIPTION_ID)?;
 
     if self.index_satoshis {
-      let mut ordinal_to_inscription_id = wtx.open_table(ORDINAL_TO_INSCRIPTION_ID)?;
-      let mut ordinal_to_satpoint = wtx.open_table(ORDINAL_TO_SATPOINT)?;
-      let mut outpoint_to_ordinal_ranges = wtx.open_table(OUTPOINT_TO_ORDINAL_RANGES)?;
+      let mut sat_to_inscription_id = wtx.open_table(SAT_TO_INSCRIPTION_ID)?;
+      let mut sat_to_satpoint = wtx.open_table(SAT_TO_SATPOINT)?;
+      let mut outpoint_to_sat_ranges = wtx.open_table(OUTPOINT_TO_SAT_RANGES)?;
 
       let mut coinbase_inputs = VecDeque::new();
 
       let h = Height(self.height);
       if h.subsidy() > 0 {
-        let start = h.starting_ordinal();
+        let start = h.starting_sat();
         coinbase_inputs.push_front((start.n(), (start + h.subsidy()).n()));
-        self.ordinal_ranges_since_flush += 1;
+        self.sat_ranges_since_flush += 1;
       }
 
       for (tx_offset, (tx, txid)) in block.txdata.iter().enumerate().skip(1) {
         log::trace!("Indexing transaction {tx_offset}…");
 
-        let mut input_ordinal_ranges = VecDeque::new();
+        let mut input_sat_ranges = VecDeque::new();
 
         for input in &tx.input {
           let key = encode_outpoint(input.previous_output);
 
-          let ordinal_ranges = match self.cache.remove(&key) {
-            Some(ordinal_ranges) => {
+          let sat_ranges = match self.cache.remove(&key) {
+            Some(sat_ranges) => {
               self.outputs_cached += 1;
-              ordinal_ranges
+              sat_ranges
             }
-            None => outpoint_to_ordinal_ranges
+            None => outpoint_to_sat_ranges
               .remove(&key)?
               .ok_or_else(|| anyhow!("Could not find outpoint {} in index", input.previous_output))?
               .to_value()
               .to_vec(),
           };
 
-          for chunk in ordinal_ranges.chunks_exact(11) {
-            input_ordinal_ranges.push_back(Index::decode_ordinal_range(chunk.try_into().unwrap()));
+          for chunk in sat_ranges.chunks_exact(11) {
+            input_sat_ranges.push_back(Index::decode_sat_range(chunk.try_into().unwrap()));
           }
         }
 
-        self.index_transaction_ordinals(
+        self.index_transaction_sats(
           tx,
           *txid,
-          &mut ordinal_to_satpoint,
-          &mut ordinal_to_inscription_id,
+          &mut sat_to_satpoint,
+          &mut sat_to_inscription_id,
           &mut inscription_id_to_satpoint,
           &mut satpoint_to_inscription_id,
-          &mut input_ordinal_ranges,
-          &mut ordinal_ranges_written,
+          &mut input_sat_ranges,
+          &mut sat_ranges_written,
           &mut outputs_in_block,
         )?;
 
-        coinbase_inputs.extend(input_ordinal_ranges);
+        coinbase_inputs.extend(input_sat_ranges);
       }
 
       if let Some((tx, txid)) = block.txdata.get(0) {
-        self.index_transaction_ordinals(
+        self.index_transaction_sats(
           tx,
           *txid,
-          &mut ordinal_to_satpoint,
-          &mut ordinal_to_inscription_id,
+          &mut sat_to_satpoint,
+          &mut sat_to_inscription_id,
           &mut inscription_id_to_satpoint,
           &mut satpoint_to_inscription_id,
           &mut coinbase_inputs,
-          &mut ordinal_ranges_written,
+          &mut sat_ranges_written,
           &mut outputs_in_block,
         )?;
       }
@@ -359,7 +359,7 @@ impl Updater {
     self.outputs_traversed += outputs_in_block;
 
     log::info!(
-      "Wrote {ordinal_ranges_written} ordinal ranges from {outputs_in_block} outputs in {} ms",
+      "Wrote {sat_ranges_written} sat ranges from {outputs_in_block} outputs in {} ms",
       (Instant::now() - start).as_millis(),
     );
 
@@ -417,16 +417,16 @@ impl Updater {
     Ok(inscribed)
   }
 
-  pub(crate) fn index_transaction_ordinals(
+  pub(crate) fn index_transaction_sats(
     &mut self,
     tx: &Transaction,
     txid: Txid,
-    ordinal_to_satpoint: &mut Table<u64, &SatPointArray>,
-    ordinal_to_inscription_id: &mut Table<u64, &InscriptionIdArray>,
+    sat_to_satpoint: &mut Table<u64, &SatPointArray>,
+    sat_to_inscription_id: &mut Table<u64, &InscriptionIdArray>,
     inscription_id_to_satpoint: &mut Table<&InscriptionIdArray, &SatPointArray>,
     satpoint_to_inscription_id: &mut Table<&SatPointArray, &InscriptionIdArray>,
-    input_ordinal_ranges: &mut VecDeque<(u64, u64)>,
-    ordinal_ranges_written: &mut u64,
+    input_sat_ranges: &mut VecDeque<(u64, u64)>,
+    sat_ranges_written: &mut u64,
     outputs_traversed: &mut u64,
   ) -> Result {
     if self.index_transaction_inscriptions(
@@ -435,8 +435,8 @@ impl Updater {
       inscription_id_to_satpoint,
       satpoint_to_inscription_id,
     )? {
-      if let Some((start, _end)) = input_ordinal_ranges.get(0) {
-        ordinal_to_inscription_id.insert(&start, txid.as_inner())?;
+      if let Some((start, _end)) = input_sat_ranges.get(0) {
+        sat_to_inscription_id.insert(&start, txid.as_inner())?;
       }
     }
 
@@ -445,16 +445,16 @@ impl Updater {
         vout: vout.try_into().unwrap(),
         txid,
       };
-      let mut ordinals = Vec::new();
+      let mut sats = Vec::new();
 
       let mut remaining = output.value;
       while remaining > 0 {
-        let range = input_ordinal_ranges
+        let range = input_sat_ranges
           .pop_front()
           .ok_or_else(|| anyhow!("insufficient inputs for transaction outputs"))?;
 
-        if !Ordinal(range.0).is_common() {
-          ordinal_to_satpoint.insert(
+        if !Sat(range.0).is_common() {
+          sat_to_satpoint.insert(
             &range.0,
             &encode_satpoint(SatPoint {
               outpoint,
@@ -466,9 +466,9 @@ impl Updater {
         let count = range.1 - range.0;
 
         let assigned = if count > remaining {
-          self.ordinal_ranges_since_flush += 1;
+          self.sat_ranges_since_flush += 1;
           let middle = range.0 + remaining;
-          input_ordinal_ranges.push_front((middle, range.1));
+          input_sat_ranges.push_front((middle, range.1));
           (range.0, middle)
         } else {
           range
@@ -479,16 +479,16 @@ impl Updater {
 
         let n = u128::from(base) | u128::from(delta) << 51;
 
-        ordinals.extend_from_slice(&n.to_le_bytes()[0..11]);
+        sats.extend_from_slice(&n.to_le_bytes()[0..11]);
 
         remaining -= assigned.1 - assigned.0;
 
-        *ordinal_ranges_written += 1;
+        *sat_ranges_written += 1;
       }
 
       *outputs_traversed += 1;
 
-      self.cache.insert(encode_outpoint(outpoint), ordinals);
+      self.cache.insert(encode_outpoint(outpoint), sats);
       self.outputs_inserted_since_flush += 1;
     }
 
@@ -512,10 +512,10 @@ impl Updater {
         self.outputs_inserted_since_flush,
       );
 
-      let mut outpoint_to_ordinal_ranges = wtx.open_table(OUTPOINT_TO_ORDINAL_RANGES)?;
+      let mut outpoint_to_sat_ranges = wtx.open_table(OUTPOINT_TO_SAT_RANGES)?;
 
       for (k, v) in &self.cache {
-        outpoint_to_ordinal_ranges.insert(k, v)?;
+        outpoint_to_sat_ranges.insert(k, v)?;
       }
 
       self.cache.clear();
@@ -524,12 +524,8 @@ impl Updater {
 
     Index::increment_statistic(&wtx, Statistic::OutputsTraversed, self.outputs_traversed)?;
     self.outputs_traversed = 0;
-    Index::increment_statistic(
-      &wtx,
-      Statistic::OrdinalRanges,
-      self.ordinal_ranges_since_flush,
-    )?;
-    self.ordinal_ranges_since_flush = 0;
+    Index::increment_statistic(&wtx, Statistic::SatRanges, self.sat_ranges_since_flush)?;
+    self.sat_ranges_since_flush = 0;
     Index::increment_statistic(&wtx, Statistic::Commits, 1)?;
 
     wtx.commit()?;
diff --git a/src/main.rs b/src/main.rs
index 411556d4d0..66b84eaa1f 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,8 +22,8 @@ use {
     index::{Index, List},
     inscription::Inscription,
     options::Options,
-    ordinal::Ordinal,
     rarity::Rarity,
+    sat::Sat,
     sat_point::SatPoint,
     subcommand::{server::templates::ContentHtml, Subcommand},
     tally::Tally,
@@ -84,8 +84,8 @@ mod height;
 mod index;
 mod inscription;
 mod options;
-mod ordinal;
 mod rarity;
+mod sat;
 mod sat_point;
 mod subcommand;
 mod tally;
diff --git a/src/rarity.rs b/src/rarity.rs
index a3f2e0d333..d6837ab901 100644
--- a/src/rarity.rs
+++ b/src/rarity.rs
@@ -27,14 +27,14 @@ impl Display for Rarity {
   }
 }
 
-impl From<Ordinal> for Rarity {
-  fn from(ordinal: Ordinal) -> Self {
+impl From<Sat> for Rarity {
+  fn from(sat: Sat) -> Self {
     let Degree {
       hour,
       minute,
       second,
       third,
-    } = ordinal.degree();
+    } = sat.degree();
 
     if hour == 0 && minute == 0 && second == 0 && third == 0 {
       Self::Mythic
@@ -58,41 +58,41 @@ mod tests {
 
   #[test]
   fn rarity() {
-    assert_eq!(Ordinal(0).rarity(), Rarity::Mythic);
-    assert_eq!(Ordinal(1).rarity(), Rarity::Common);
+    assert_eq!(Sat(0).rarity(), Rarity::Mythic);
+    assert_eq!(Sat(1).rarity(), Rarity::Common);
 
-    assert_eq!(Ordinal(50 * COIN_VALUE - 1).rarity(), Rarity::Common);
-    assert_eq!(Ordinal(50 * COIN_VALUE).rarity(), Rarity::Uncommon);
-    assert_eq!(Ordinal(50 * COIN_VALUE + 1).rarity(), Rarity::Common);
+    assert_eq!(Sat(50 * COIN_VALUE - 1).rarity(), Rarity::Common);
+    assert_eq!(Sat(50 * COIN_VALUE).rarity(), Rarity::Uncommon);
+    assert_eq!(Sat(50 * COIN_VALUE + 1).rarity(), Rarity::Common);
 
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * DIFFCHANGE_INTERVAL - 1).rarity(),
+      Sat(50 * COIN_VALUE * DIFFCHANGE_INTERVAL - 1).rarity(),
       Rarity::Common
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * DIFFCHANGE_INTERVAL).rarity(),
+      Sat(50 * COIN_VALUE * DIFFCHANGE_INTERVAL).rarity(),
       Rarity::Rare
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * DIFFCHANGE_INTERVAL + 1).rarity(),
+      Sat(50 * COIN_VALUE * DIFFCHANGE_INTERVAL + 1).rarity(),
       Rarity::Common
     );
 
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL - 1).rarity(),
+      Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL - 1).rarity(),
       Rarity::Common
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL).rarity(),
+      Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL).rarity(),
       Rarity::Epic
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL + 1).rarity(),
+      Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL + 1).rarity(),
       Rarity::Common
     );
 
-    assert_eq!(Ordinal(2067187500000000 - 1).rarity(), Rarity::Common);
-    assert_eq!(Ordinal(2067187500000000).rarity(), Rarity::Legendary);
-    assert_eq!(Ordinal(2067187500000000 + 1).rarity(), Rarity::Common);
+    assert_eq!(Sat(2067187500000000 - 1).rarity(), Rarity::Common);
+    assert_eq!(Sat(2067187500000000).rarity(), Rarity::Legendary);
+    assert_eq!(Sat(2067187500000000 + 1).rarity(), Rarity::Common);
   }
 }
diff --git a/src/ordinal.rs b/src/sat.rs
similarity index 64%
rename from src/ordinal.rs
rename to src/sat.rs
index d06d9f6712..fbc41f6c98 100644
--- a/src/ordinal.rs
+++ b/src/sat.rs
@@ -2,9 +2,9 @@ use super::*;
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Display, Ord, PartialOrd, Deserialize, Serialize)]
 #[serde(transparent)]
-pub(crate) struct Ordinal(pub(crate) u64);
+pub(crate) struct Sat(pub(crate) u64);
 
-impl Ordinal {
+impl Sat {
   pub(crate) const LAST: Self = Self(Self::SUPPLY - 1);
   pub(crate) const SUPPLY: u64 = 2099999997690000;
 
@@ -41,7 +41,7 @@ impl Ordinal {
   }
 
   pub(crate) fn epoch_position(self) -> u64 {
-    self.0 - self.epoch().starting_ordinal().0
+    self.0 - self.epoch().starting_sat().0
   }
 
   pub(crate) fn decimal(self) -> Decimal {
@@ -52,12 +52,12 @@ impl Ordinal {
     self.into()
   }
 
-  /// `Ordinal::rarity` is expensive and is called frequently when indexing.
-  /// Ordinal::is_common only checks if self is `Rarity::Common` but is
+  /// `Sat::rarity` is expensive and is called frequently when indexing.
+  /// Sat::is_common only checks if self is `Rarity::Common` but is
   /// much faster.
   pub(crate) fn is_common(self) -> bool {
     let epoch = self.epoch();
-    (self.0 - epoch.starting_ordinal().0) % epoch.subsidy() != 0
+    (self.0 - epoch.starting_sat().0) % epoch.subsidy() != 0
   }
 
   pub(crate) fn name(self) -> String {
@@ -82,13 +82,13 @@ impl Ordinal {
         'a'..='z' => {
           x = x * 26 + c as u64 - 'a' as u64 + 1;
         }
-        _ => bail!("invalid character in ordinal name: {c}"),
+        _ => bail!("invalid character in sat name: {c}"),
       }
     }
     if x > Self::SUPPLY {
-      bail!("ordinal name out of range");
+      bail!("sat name out of range");
     }
-    Ok(Ordinal(Self::SUPPLY - x))
+    Ok(Sat(Self::SUPPLY - x))
   }
 
   fn from_degree(degree: &str) -> Result<Self> {
@@ -144,7 +144,7 @@ impl Ordinal {
       bail!("invalid block offset");
     }
 
-    Ok(height.starting_ordinal() + block_offset)
+    Ok(height.starting_sat() + block_offset)
   }
 
   fn from_decimal(decimal: &str) -> Result<Self> {
@@ -158,7 +158,7 @@ impl Ordinal {
       bail!("invalid block offset");
     }
 
-    Ok(height.starting_ordinal() + offset)
+    Ok(height.starting_sat() + offset)
   }
 
   fn from_percentile(percentile: &str) -> Result<Self> {
@@ -172,7 +172,7 @@ impl Ordinal {
       bail!("invalid percentile: {}", percentile);
     }
 
-    let last = Ordinal::LAST.n() as f64;
+    let last = Sat::LAST.n() as f64;
 
     let n = (percentile / 100.0 * last).round();
 
@@ -181,37 +181,37 @@ impl Ordinal {
     }
 
     #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
-    Ok(Ordinal(n as u64))
+    Ok(Sat(n as u64))
   }
 }
 
-impl PartialEq<u64> for Ordinal {
+impl PartialEq<u64> for Sat {
   fn eq(&self, other: &u64) -> bool {
     self.0 == *other
   }
 }
 
-impl PartialOrd<u64> for Ordinal {
+impl PartialOrd<u64> for Sat {
   fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
     self.0.partial_cmp(other)
   }
 }
 
-impl Add<u64> for Ordinal {
+impl Add<u64> for Sat {
   type Output = Self;
 
-  fn add(self, other: u64) -> Ordinal {
-    Ordinal(self.0 + other)
+  fn add(self, other: u64) -> Sat {
+    Sat(self.0 + other)
   }
 }
 
-impl AddAssign<u64> for Ordinal {
+impl AddAssign<u64> for Sat {
   fn add_assign(&mut self, other: u64) {
-    *self = Ordinal(self.0 + other);
+    *self = Sat(self.0 + other);
   }
 }
 
-impl FromStr for Ordinal {
+impl FromStr for Sat {
   type Err = Error;
 
   fn from_str(s: &str) -> Result<Self> {
@@ -224,11 +224,11 @@ impl FromStr for Ordinal {
     } else if s.contains('.') {
       Self::from_decimal(s)
     } else {
-      let ordinal = Self(s.parse()?);
-      if ordinal > Self::LAST {
-        Err(anyhow!("invalid ordinal"))
+      let sat = Self(s.parse()?);
+      if sat > Self::LAST {
+        Err(anyhow!("invalid sat"))
       } else {
-        Ok(ordinal)
+        Ok(sat)
       }
     }
   }
@@ -240,100 +240,94 @@ mod tests {
 
   #[test]
   fn n() {
-    assert_eq!(Ordinal(1).n(), 1);
-    assert_eq!(Ordinal(100).n(), 100);
+    assert_eq!(Sat(1).n(), 1);
+    assert_eq!(Sat(100).n(), 100);
   }
 
   #[test]
   fn height() {
-    assert_eq!(Ordinal(0).height(), 0);
-    assert_eq!(Ordinal(1).height(), 0);
-    assert_eq!(Ordinal(Epoch(0).subsidy()).height(), 1);
-    assert_eq!(Ordinal(Epoch(0).subsidy() * 2).height(), 2);
+    assert_eq!(Sat(0).height(), 0);
+    assert_eq!(Sat(1).height(), 0);
+    assert_eq!(Sat(Epoch(0).subsidy()).height(), 1);
+    assert_eq!(Sat(Epoch(0).subsidy() * 2).height(), 2);
     assert_eq!(
-      Epoch(2).starting_ordinal().height(),
+      Epoch(2).starting_sat().height(),
       SUBSIDY_HALVING_INTERVAL * 2
     );
-    assert_eq!(Ordinal(50 * COIN_VALUE).height(), 1);
-    assert_eq!(Ordinal(2099999997689999).height(), 6929999);
-    assert_eq!(Ordinal(2099999997689998).height(), 6929998);
+    assert_eq!(Sat(50 * COIN_VALUE).height(), 1);
+    assert_eq!(Sat(2099999997689999).height(), 6929999);
+    assert_eq!(Sat(2099999997689998).height(), 6929998);
   }
 
   #[test]
   fn name() {
-    assert_eq!(Ordinal(0).name(), "nvtdijuwxlp");
-    assert_eq!(Ordinal(1).name(), "nvtdijuwxlo");
-    assert_eq!(Ordinal(26).name(), "nvtdijuwxkp");
-    assert_eq!(Ordinal(27).name(), "nvtdijuwxko");
-    assert_eq!(Ordinal(2099999997689999).name(), "a");
-    assert_eq!(Ordinal(2099999997689999 - 1).name(), "b");
-    assert_eq!(Ordinal(2099999997689999 - 25).name(), "z");
-    assert_eq!(Ordinal(2099999997689999 - 26).name(), "aa");
+    assert_eq!(Sat(0).name(), "nvtdijuwxlp");
+    assert_eq!(Sat(1).name(), "nvtdijuwxlo");
+    assert_eq!(Sat(26).name(), "nvtdijuwxkp");
+    assert_eq!(Sat(27).name(), "nvtdijuwxko");
+    assert_eq!(Sat(2099999997689999).name(), "a");
+    assert_eq!(Sat(2099999997689999 - 1).name(), "b");
+    assert_eq!(Sat(2099999997689999 - 25).name(), "z");
+    assert_eq!(Sat(2099999997689999 - 26).name(), "aa");
   }
 
   #[test]
   fn number() {
-    assert_eq!(Ordinal(2099999997689999).n(), 2099999997689999);
+    assert_eq!(Sat(2099999997689999).n(), 2099999997689999);
   }
 
   #[test]
   fn degree() {
-    assert_eq!(Ordinal(0).degree().to_string(), "0°0′0″0‴");
-    assert_eq!(Ordinal(1).degree().to_string(), "0°0′0″1‴");
+    assert_eq!(Sat(0).degree().to_string(), "0°0′0″0‴");
+    assert_eq!(Sat(1).degree().to_string(), "0°0′0″1‴");
     assert_eq!(
-      Ordinal(50 * COIN_VALUE - 1).degree().to_string(),
+      Sat(50 * COIN_VALUE - 1).degree().to_string(),
       "0°0′0″4999999999‴"
     );
-    assert_eq!(Ordinal(50 * COIN_VALUE).degree().to_string(), "0°1′1″0‴");
+    assert_eq!(Sat(50 * COIN_VALUE).degree().to_string(), "0°1′1″0‴");
+    assert_eq!(Sat(50 * COIN_VALUE + 1).degree().to_string(), "0°1′1″1‴");
     assert_eq!(
-      Ordinal(50 * COIN_VALUE + 1).degree().to_string(),
-      "0°1′1″1‴"
-    );
-    assert_eq!(
-      Ordinal(50 * COIN_VALUE * DIFFCHANGE_INTERVAL - 1)
+      Sat(50 * COIN_VALUE * DIFFCHANGE_INTERVAL - 1)
         .degree()
         .to_string(),
       "0°2015′2015″4999999999‴"
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * DIFFCHANGE_INTERVAL)
+      Sat(50 * COIN_VALUE * DIFFCHANGE_INTERVAL)
         .degree()
         .to_string(),
       "0°2016′0″0‴"
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * DIFFCHANGE_INTERVAL + 1)
+      Sat(50 * COIN_VALUE * DIFFCHANGE_INTERVAL + 1)
         .degree()
         .to_string(),
       "0°2016′0″1‴"
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL - 1)
+      Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL - 1)
         .degree()
         .to_string(),
       "0°209999′335″4999999999‴"
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL)
+      Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL)
         .degree()
         .to_string(),
       "0°0′336″0‴"
     );
     assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL + 1)
+      Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL + 1)
         .degree()
         .to_string(),
       "0°0′336″1‴"
     );
     assert_eq!(
-      Ordinal(2067187500000000 - 1).degree().to_string(),
+      Sat(2067187500000000 - 1).degree().to_string(),
       "0°209999′2015″156249999‴"
     );
-    assert_eq!(Ordinal(2067187500000000).degree().to_string(), "1°0′0″0‴");
-    assert_eq!(
-      Ordinal(2067187500000000 + 1).degree().to_string(),
-      "1°0′0″1‴"
-    );
+    assert_eq!(Sat(2067187500000000).degree().to_string(), "1°0′0″0‴");
+    assert_eq!(Sat(2067187500000000 + 1).degree().to_string(), "1°0′0″1‴");
   }
 
   #[test]
@@ -341,23 +335,20 @@ mod tests {
     // Break glass in case of emergency:
     // for height in 0..(2 * CYCLE_EPOCHS * Epoch::BLOCKS) {
     //   // 1054200000000000
-    //   let expected = Height(height).starting_ordinal();
+    //   let expected = Height(height).starting_sat();
     //   // 0°1680′0″0‴
     //   let degree = expected.degree();
     //   // 2034637500000000
-    //   let actual = degree.to_string().parse::<Ordinal>().unwrap();
+    //   let actual = degree.to_string().parse::<Sat>().unwrap();
     //   assert_eq!(
     //     actual, expected,
-    //     "Ordinal at height {height} did not round-trip from degree {degree} successfully"
+    //     "Sat at height {height} did not round-trip from degree {degree} successfully"
     //   );
     // }
-    assert_eq!(
-      Ordinal(1054200000000000).degree().to_string(),
-      "0°1680′0″0‴"
-    );
+    assert_eq!(Sat(1054200000000000).degree().to_string(), "0°1680′0″0‴");
     assert_eq!(parse("0°1680′0″0‴").unwrap(), 1054200000000000);
     assert_eq!(
-      Ordinal(1914226250000000).degree().to_string(),
+      Sat(1914226250000000).degree().to_string(),
       "0°122762′794″0‴"
     );
     assert_eq!(parse("0°122762′794″0‴").unwrap(), 1914226250000000);
@@ -365,51 +356,48 @@ mod tests {
 
   #[test]
   fn period() {
-    assert_eq!(Ordinal(0).period(), 0);
-    assert_eq!(Ordinal(10080000000000).period(), 1);
-    assert_eq!(Ordinal(2099999997689999).period(), 3437);
-    assert_eq!(Ordinal(10075000000000).period(), 0);
-    assert_eq!(Ordinal(10080000000000 - 1).period(), 0);
-    assert_eq!(Ordinal(10080000000000).period(), 1);
-    assert_eq!(Ordinal(10080000000000 + 1).period(), 1);
-    assert_eq!(Ordinal(10085000000000).period(), 1);
-    assert_eq!(Ordinal(2099999997689999).period(), 3437);
+    assert_eq!(Sat(0).period(), 0);
+    assert_eq!(Sat(10080000000000).period(), 1);
+    assert_eq!(Sat(2099999997689999).period(), 3437);
+    assert_eq!(Sat(10075000000000).period(), 0);
+    assert_eq!(Sat(10080000000000 - 1).period(), 0);
+    assert_eq!(Sat(10080000000000).period(), 1);
+    assert_eq!(Sat(10080000000000 + 1).period(), 1);
+    assert_eq!(Sat(10085000000000).period(), 1);
+    assert_eq!(Sat(2099999997689999).period(), 3437);
   }
 
   #[test]
   fn epoch() {
-    assert_eq!(Ordinal(0).epoch(), 0);
-    assert_eq!(Ordinal(1).epoch(), 0);
-    assert_eq!(
-      Ordinal(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL).epoch(),
-      1
-    );
-    assert_eq!(Ordinal(2099999997689999).epoch(), 32);
+    assert_eq!(Sat(0).epoch(), 0);
+    assert_eq!(Sat(1).epoch(), 0);
+    assert_eq!(Sat(50 * COIN_VALUE * SUBSIDY_HALVING_INTERVAL).epoch(), 1);
+    assert_eq!(Sat(2099999997689999).epoch(), 32);
   }
 
   #[test]
   fn epoch_position() {
-    assert_eq!(Epoch(0).starting_ordinal().epoch_position(), 0);
-    assert_eq!((Epoch(0).starting_ordinal() + 100).epoch_position(), 100);
-    assert_eq!(Epoch(1).starting_ordinal().epoch_position(), 0);
-    assert_eq!(Epoch(2).starting_ordinal().epoch_position(), 0);
+    assert_eq!(Epoch(0).starting_sat().epoch_position(), 0);
+    assert_eq!((Epoch(0).starting_sat() + 100).epoch_position(), 100);
+    assert_eq!(Epoch(1).starting_sat().epoch_position(), 0);
+    assert_eq!(Epoch(2).starting_sat().epoch_position(), 0);
   }
 
   #[test]
   fn subsidy_position() {
-    assert_eq!(Ordinal(0).third(), 0);
-    assert_eq!(Ordinal(1).third(), 1);
+    assert_eq!(Sat(0).third(), 0);
+    assert_eq!(Sat(1).third(), 1);
     assert_eq!(
-      Ordinal(Height(0).subsidy() - 1).third(),
+      Sat(Height(0).subsidy() - 1).third(),
       Height(0).subsidy() - 1
     );
-    assert_eq!(Ordinal(Height(0).subsidy()).third(), 0);
-    assert_eq!(Ordinal(Height(0).subsidy() + 1).third(), 1);
+    assert_eq!(Sat(Height(0).subsidy()).third(), 0);
+    assert_eq!(Sat(Height(0).subsidy() + 1).third(), 1);
     assert_eq!(
-      Ordinal(Epoch(1).starting_ordinal().n() + Epoch(1).subsidy()).third(),
+      Sat(Epoch(1).starting_sat().n() + Epoch(1).subsidy()).third(),
       0
     );
-    assert_eq!(Ordinal::LAST.third(), 0);
+    assert_eq!(Sat::LAST.third(), 0);
   }
 
   #[test]
@@ -426,43 +414,43 @@ mod tests {
       mined += subsidy;
     }
 
-    assert_eq!(Ordinal::SUPPLY, mined);
+    assert_eq!(Sat::SUPPLY, mined);
   }
 
   #[test]
   fn last() {
-    assert_eq!(Ordinal::LAST, Ordinal::SUPPLY - 1);
+    assert_eq!(Sat::LAST, Sat::SUPPLY - 1);
   }
 
   #[test]
   fn eq() {
-    assert_eq!(Ordinal(0), 0);
-    assert_eq!(Ordinal(1), 1);
+    assert_eq!(Sat(0), 0);
+    assert_eq!(Sat(1), 1);
   }
 
   #[test]
   fn partial_ord() {
-    assert!(Ordinal(1) > 0);
-    assert!(Ordinal(0) < 1);
+    assert!(Sat(1) > 0);
+    assert!(Sat(0) < 1);
   }
 
   #[test]
   fn add() {
-    assert_eq!(Ordinal(0) + 1, 1);
-    assert_eq!(Ordinal(1) + 100, 101);
+    assert_eq!(Sat(0) + 1, 1);
+    assert_eq!(Sat(1) + 100, 101);
   }
 
   #[test]
   fn add_assign() {
-    let mut ordinal = Ordinal(0);
-    ordinal += 1;
-    assert_eq!(ordinal, 1);
-    ordinal += 100;
-    assert_eq!(ordinal, 101);
+    let mut sat = Sat(0);
+    sat += 1;
+    assert_eq!(sat, 1);
+    sat += 100;
+    assert_eq!(sat, 101);
   }
 
-  fn parse(s: &str) -> Result<Ordinal, String> {
-    s.parse::<Ordinal>().map_err(|e| e.to_string())
+  fn parse(s: &str) -> Result<Sat, String> {
+    s.parse::<Sat>().map_err(|e| e.to_string())
   }
 
   #[test]
@@ -573,59 +561,53 @@ mod tests {
       0
     );
 
-    assert_eq!(Ordinal(0).cycle(), 0);
-    assert_eq!(Ordinal(2067187500000000 - 1).cycle(), 0);
-    assert_eq!(Ordinal(2067187500000000).cycle(), 1);
-    assert_eq!(Ordinal(2067187500000000 + 1).cycle(), 1);
+    assert_eq!(Sat(0).cycle(), 0);
+    assert_eq!(Sat(2067187500000000 - 1).cycle(), 0);
+    assert_eq!(Sat(2067187500000000).cycle(), 1);
+    assert_eq!(Sat(2067187500000000 + 1).cycle(), 1);
   }
 
   #[test]
   fn third() {
-    assert_eq!(Ordinal(0).third(), 0);
-    assert_eq!(Ordinal(50 * COIN_VALUE - 1).third(), 4999999999);
-    assert_eq!(Ordinal(50 * COIN_VALUE).third(), 0);
-    assert_eq!(Ordinal(50 * COIN_VALUE + 1).third(), 1);
+    assert_eq!(Sat(0).third(), 0);
+    assert_eq!(Sat(50 * COIN_VALUE - 1).third(), 4999999999);
+    assert_eq!(Sat(50 * COIN_VALUE).third(), 0);
+    assert_eq!(Sat(50 * COIN_VALUE + 1).third(), 1);
   }
 
   #[test]
   fn percentile() {
-    assert_eq!(Ordinal(0).percentile(), "0%");
-    assert_eq!(
-      Ordinal(Ordinal::LAST.n() / 2).percentile(),
-      "49.99999999999998%"
-    );
-    assert_eq!(Ordinal::LAST.percentile(), "100%");
+    assert_eq!(Sat(0).percentile(), "0%");
+    assert_eq!(Sat(Sat::LAST.n() / 2).percentile(), "49.99999999999998%");
+    assert_eq!(Sat::LAST.percentile(), "100%");
   }
 
   #[test]
   fn from_percentile() {
-    "-1%".parse::<Ordinal>().unwrap_err();
-    "101%".parse::<Ordinal>().unwrap_err();
+    "-1%".parse::<Sat>().unwrap_err();
+    "101%".parse::<Sat>().unwrap_err();
   }
 
   #[test]
   fn percentile_round_trip() {
     fn case(n: u64) {
-      let expected = Ordinal(n);
-      let actual = expected.percentile().parse::<Ordinal>().unwrap();
+      let expected = Sat(n);
+      let actual = expected.percentile().parse::<Sat>().unwrap();
       assert_eq!(expected, actual);
     }
 
     for n in 0..1024 {
       case(n);
-      case(Ordinal::LAST.n() / 2 + n);
-      case(Ordinal::LAST.n() - n);
-      case(Ordinal::LAST.n() / (n + 1));
+      case(Sat::LAST.n() / 2 + n);
+      case(Sat::LAST.n() - n);
+      case(Sat::LAST.n() / (n + 1));
     }
   }
 
   #[test]
   fn is_common() {
     fn case(n: u64) {
-      assert_eq!(
-        Ordinal(n).is_common(),
-        Ordinal(n).rarity() == Rarity::Common
-      );
+      assert_eq!(Sat(n).is_common(), Sat(n).rarity() == Rarity::Common);
     }
 
     case(0);
diff --git a/src/subcommand/epochs.rs b/src/subcommand/epochs.rs
index d8d9b3788d..aeff9afa11 100644
--- a/src/subcommand/epochs.rs
+++ b/src/subcommand/epochs.rs
@@ -1,8 +1,8 @@
 use super::*;
 
 pub(crate) fn run() -> Result {
-  for ordinal in Epoch::STARTING_ORDINALS {
-    println!("{}", ordinal);
+  for sat in Epoch::STARTING_SATS {
+    println!("{}", sat);
   }
   Ok(())
 }
diff --git a/src/subcommand/find.rs b/src/subcommand/find.rs
index 0e0c9df0ef..e06132797c 100644
--- a/src/subcommand/find.rs
+++ b/src/subcommand/find.rs
@@ -2,8 +2,8 @@ use super::*;
 
 #[derive(Debug, Parser)]
 pub(crate) struct Find {
-  #[clap(help = "Find output and offset of <ORDINAL>.")]
-  ordinal: Ordinal,
+  #[clap(help = "Find output and offset of <SAT>.")]
+  sat: Sat,
 }
 
 impl Find {
@@ -12,12 +12,12 @@ impl Find {
 
     index.update()?;
 
-    match index.find(self.ordinal.0)? {
+    match index.find(self.sat.0)? {
       Some(satpoint) => {
         println!("{satpoint}");
         Ok(())
       }
-      None => Err(anyhow!("ordinal has not been mined as of index height")),
+      None => Err(anyhow!("sat has not been mined as of index height")),
     }
   }
 }
diff --git a/src/subcommand/list.rs b/src/subcommand/list.rs
index ffd961cfef..fb3f493256 100644
--- a/src/subcommand/list.rs
+++ b/src/subcommand/list.rs
@@ -2,7 +2,7 @@ use super::*;
 
 #[derive(Debug, Parser)]
 pub(crate) struct List {
-  #[clap(help = "List ordinals in <OUTPOINT>.")]
+  #[clap(help = "List sats in <OUTPOINT>.")]
   outpoint: OutPoint,
 }
 
@@ -31,8 +31,8 @@ fn list(outpoint: OutPoint, ranges: Vec<(u64, u64)>) -> Vec<(OutPoint, u64, u64,
     .into_iter()
     .map(|(start, end)| {
       let size = end - start;
-      let rarity = Ordinal(start).rarity();
-      let name = Ordinal(start).name();
+      let rarity = Sat(start).rarity();
+      let name = Sat(start).name();
 
       (outpoint, start, size, rarity, name)
     })
diff --git a/src/subcommand/parse.rs b/src/subcommand/parse.rs
index aa0325f2d0..dbad53e030 100644
--- a/src/subcommand/parse.rs
+++ b/src/subcommand/parse.rs
@@ -2,13 +2,13 @@ use super::*;
 
 #[derive(Debug, Parser)]
 pub(crate) struct Parse {
-  #[clap(help = "Parse <ORDINAL>.")]
-  ordinal: Ordinal,
+  #[clap(help = "Parse <SAT>.")]
+  sat: Sat,
 }
 
 impl Parse {
   pub(crate) fn run(self) -> Result {
-    println!("{}", self.ordinal);
+    println!("{}", self.sat);
     Ok(())
   }
 }
diff --git a/src/subcommand/server.rs b/src/subcommand/server.rs
index 196994ac3a..3f5418113e 100644
--- a/src/subcommand/server.rs
+++ b/src/subcommand/server.rs
@@ -4,8 +4,8 @@ use {
   self::{
     deserialize_from_str::DeserializeFromStr,
     templates::{
-      BlockHtml, ClockSvg, HomeHtml, InputHtml, InscriptionHtml, OrdinalHtml, OutputHtml,
-      PageContent, PageHtml, RangeHtml, RareTxt, TransactionHtml,
+      BlockHtml, ClockSvg, HomeHtml, InputHtml, InscriptionHtml, OutputHtml, PageContent, PageHtml,
+      RangeHtml, RareTxt, SatHtml, TransactionHtml,
     },
   },
   axum::{
@@ -159,10 +159,11 @@ impl Server {
         .route("/input/:block/:transaction/:input", get(Self::input))
         .route("/inscription/:txid", get(Self::inscription))
         .route("/install.sh", get(Self::install_script))
-        .route("/ordinal/:ordinal", get(Self::ordinal))
+        .route("/ordinal/:sat", get(Self::ordinal))
         .route("/output/:output", get(Self::output))
         .route("/range/:start/:end", get(Self::range))
         .route("/rare.txt", get(Self::rare_txt))
+        .route("/sat/:sat", get(Self::sat))
         .route("/search", get(Self::search_by_query))
         .route("/search/:query", get(Self::search_by_path))
         .route("/static/*path", get(Self::static_asset))
@@ -304,20 +305,20 @@ impl Server {
     Ok(ClockSvg::new(Self::index_height(&index)?))
   }
 
-  async fn ordinal(
+  async fn sat(
     Extension(chain): Extension<Chain>,
     Extension(index): Extension<Arc<Index>>,
-    Path(DeserializeFromStr(ordinal)): Path<DeserializeFromStr<Ordinal>>,
+    Path(DeserializeFromStr(sat)): Path<DeserializeFromStr<Sat>>,
   ) -> ServerResult<PageHtml> {
     Ok(
-      OrdinalHtml {
-        ordinal,
-        blocktime: index.blocktime(ordinal.height()).map_err(|err| {
+      SatHtml {
+        sat,
+        blocktime: index.blocktime(sat.height()).map_err(|err| {
           ServerError::Internal(anyhow!("failed to retrieve blocktime from index: {err}"))
         })?,
-        inscription: index.get_inscription_by_ordinal(ordinal).map_err(|err| {
+        inscription: index.get_inscription_by_sat(sat).map_err(|err| {
           ServerError::Internal(anyhow!(
-            "failed to retrieve inscription for ordinal {ordinal} from index: {err}"
+            "failed to retrieve inscription for sat {sat} from index: {err}"
           ))
         })?,
       }
@@ -328,6 +329,10 @@ impl Server {
     )
   }
 
+  async fn ordinal(Path(sat): Path<String>) -> Redirect {
+    Redirect::to(&format!("/sat/{sat}"))
+  }
+
   async fn output(
     Extension(chain): Extension<Chain>,
     Extension(index): Extension<Arc<Index>>,
@@ -369,8 +374,8 @@ impl Server {
     Extension(chain): Extension<Chain>,
     Extension(index): Extension<Arc<Index>>,
     Path((DeserializeFromStr(start), DeserializeFromStr(end))): Path<(
-      DeserializeFromStr<Ordinal>,
-      DeserializeFromStr<Ordinal>,
+      DeserializeFromStr<Sat>,
+      DeserializeFromStr<Sat>,
     )>,
   ) -> ServerResult<PageHtml> {
     match start.cmp(&end) {
@@ -388,13 +393,11 @@ impl Server {
   async fn rare_txt(Extension(index): Extension<Arc<Index>>) -> ServerResult<RareTxt> {
     Ok(RareTxt(
       index
-        .rare_ordinal_satpoints()
-        .map_err(|err| {
-          ServerError::Internal(anyhow!("error getting rare ordinal satpoints: {err}"))
-        })?
+        .rare_sat_satpoints()
+        .map_err(|err| ServerError::Internal(anyhow!("error getting rare sat satpoints: {err}")))?
         .ok_or_else(|| {
           ServerError::NotFound(
-            "tracking rare ordinals requires index created with `--index-satoshis` flag".into(),
+            "tracking rare sats requires index created with `--index-satoshis` flag".into(),
           )
         })?,
     ))
@@ -561,7 +564,7 @@ impl Server {
     } else if OUTPOINT.is_match(query) {
       Ok(Redirect::to(&format!("/output/{query}")))
     } else {
-      Ok(Redirect::to(&format!("/ordinal/{query}")))
+      Ok(Redirect::to(&format!("/sat/{query}")))
     }
   }
 
@@ -720,7 +723,7 @@ mod tests {
       }
 
       for i in 0.. {
-        match reqwest::blocking::get(&format!("http://127.0.0.1:{port}/status")) {
+        match reqwest::blocking::get(format!("http://127.0.0.1:{port}/status")) {
           Ok(_) => break,
           Err(err) => {
             if i == 400 {
@@ -966,6 +969,11 @@ mod tests {
     );
   }
 
+  #[test]
+  fn ordinal_redirects_to_sat() {
+    TestServer::new().assert_redirect("/ordinal/0", "/sat/0");
+  }
+
   #[test]
   fn bounties_redirects_to_docs_site() {
     TestServer::new().assert_redirect("/bounties", "https://docs.ordinals.com/bounty/");
@@ -977,18 +985,18 @@ mod tests {
   }
 
   #[test]
-  fn search_by_query_returns_ordinal() {
-    TestServer::new().assert_redirect("/search?query=0", "/ordinal/0");
+  fn search_by_query_returns_sat() {
+    TestServer::new().assert_redirect("/search?query=0", "/sat/0");
   }
 
   #[test]
   fn search_is_whitespace_insensitive() {
-    TestServer::new().assert_redirect("/search/ 0 ", "/ordinal/0");
+    TestServer::new().assert_redirect("/search/ 0 ", "/sat/0");
   }
 
   #[test]
-  fn search_by_path_returns_ordinal() {
-    TestServer::new().assert_redirect("/search/0", "/ordinal/0");
+  fn search_by_path_returns_sat() {
+    TestServer::new().assert_redirect("/search/0", "/sat/0");
   }
 
   #[test]
@@ -1074,60 +1082,52 @@ mod tests {
     TestServer::new().assert_response_regex(
       "/range/0/1",
       StatusCode::OK,
-      r".*<title>Ordinal range 0–1</title>.*<h1>Ordinal range 0–1</h1>
+      r".*<title>Sat range 0–1</title>.*<h1>Sat range 0–1</h1>
 <dl>
   <dt>value</dt><dd>1</dd>
-  <dt>first</dt><dd><a href=/ordinal/0 class=mythic>0</a></dd>
+  <dt>first</dt><dd><a href=/sat/0 class=mythic>0</a></dd>
 </dl>.*",
     );
   }
   #[test]
-  fn ordinal_number() {
-    TestServer::new().assert_response_regex("/ordinal/0", StatusCode::OK, ".*<h1>Ordinal 0</h1>.*");
+  fn sat_number() {
+    TestServer::new().assert_response_regex("/sat/0", StatusCode::OK, ".*<h1>Sat 0</h1>.*");
   }
 
   #[test]
-  fn ordinal_decimal() {
-    TestServer::new().assert_response_regex(
-      "/ordinal/0.0",
-      StatusCode::OK,
-      ".*<h1>Ordinal 0</h1>.*",
-    );
+  fn sat_decimal() {
+    TestServer::new().assert_response_regex("/sat/0.0", StatusCode::OK, ".*<h1>Sat 0</h1>.*");
   }
 
   #[test]
-  fn ordinal_degree() {
-    TestServer::new().assert_response_regex(
-      "/ordinal/0°0′0″0‴",
-      StatusCode::OK,
-      ".*<h1>Ordinal 0</h1>.*",
-    );
+  fn sat_degree() {
+    TestServer::new().assert_response_regex("/sat/0°0′0″0‴", StatusCode::OK, ".*<h1>Sat 0</h1>.*");
   }
 
   #[test]
-  fn ordinal_name() {
+  fn sat_name() {
     TestServer::new().assert_response_regex(
-      "/ordinal/nvtdijuwxlp",
+      "/sat/nvtdijuwxlp",
       StatusCode::OK,
-      ".*<h1>Ordinal 0</h1>.*",
+      ".*<h1>Sat 0</h1>.*",
     );
   }
 
   #[test]
-  fn ordinal() {
+  fn sat() {
     TestServer::new().assert_response_regex(
-      "/ordinal/0",
+      "/sat/0",
       StatusCode::OK,
-      ".*<title>0°0′0″0‴</title>.*<h1>Ordinal 0</h1>.*",
+      ".*<title>0°0′0″0‴</title>.*<h1>Sat 0</h1>.*",
     );
   }
 
   #[test]
-  fn ordinal_out_of_range() {
+  fn sat_out_of_range() {
     TestServer::new().assert_response(
-      "/ordinal/2099999997690000",
+      "/sat/2099999997690000",
       StatusCode::BAD_REQUEST,
-      "Invalid URL: invalid ordinal",
+      "Invalid URL: invalid sat",
     );
   }
 
@@ -1150,7 +1150,7 @@ mod tests {
   <dt>value</dt><dd>5000000000</dd>
   <dt>script pubkey</dt><dd class=data>OP_PUSHBYTES_65 04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f OP_CHECKSIG</dd>
 </dl>
-<h2>1 Ordinal Range</h2>
+<h2>1 Sat Range</h2>
 <ul class=monospace>
   <li><a href=/range/0/5000000000 class=mythic>0–5000000000</a></li>
 </ul>.*",
@@ -1250,18 +1250,18 @@ mod tests {
   }
 
   #[test]
-  fn unmined_ordinal() {
+  fn unmined_sat() {
     TestServer::new().assert_response_regex(
-      "/ordinal/0",
+      "/sat/0",
       StatusCode::OK,
       ".*<dt>time</dt><dd>2009-01-03 18:15:05</dd>.*",
     );
   }
 
   #[test]
-  fn mined_ordinal() {
+  fn mined_sat() {
     TestServer::new().assert_response_regex(
-      "/ordinal/5000000000",
+      "/sat/5000000000",
       StatusCode::OK,
       ".*<dt>time</dt><dd>.* \\(expected\\)</dd>.*",
     );
@@ -1393,7 +1393,7 @@ next.*",
     TestServer::new_with_args(&["--index-satoshis"]).assert_response(
       "/rare.txt",
       StatusCode::OK,
-      "ordinal\tsatpoint
+      "sat\tsatpoint
 0\t4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b:0:0
 ",
     );
@@ -1404,7 +1404,7 @@ next.*",
     TestServer::new_with_args(&[]).assert_response(
       "/rare.txt",
       StatusCode::NOT_FOUND,
-      "tracking rare ordinals requires index created with `--index-satoshis` flag",
+      "tracking rare sats requires index created with `--index-satoshis` flag",
     );
   }
 
@@ -1538,13 +1538,13 @@ next.*",
   }
 
   #[test]
-  fn coinbase_ordinal_ranges_are_tracked() {
+  fn coinbase_sat_ranges_are_tracked() {
     let server = TestServer::new_with_args(&["--index-satoshis"]);
 
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       1
     );
@@ -1555,7 +1555,7 @@ next.*",
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       2
     );
@@ -1566,20 +1566,20 @@ next.*",
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       3
     );
   }
 
   #[test]
-  fn split_ordinal_ranges_are_tracked() {
+  fn split_sat_ranges_are_tracked() {
     let server = TestServer::new_with_args(&["--index-satoshis"]);
 
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       1
     );
@@ -1596,20 +1596,20 @@ next.*",
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       4,
     );
   }
 
   #[test]
-  fn fee_ordinal_ranges_are_tracked() {
+  fn fee_sat_ranges_are_tracked() {
     let server = TestServer::new_with_args(&["--index-satoshis"]);
 
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       1
     );
@@ -1626,7 +1626,7 @@ next.*",
     assert_eq!(
       server
         .index
-        .statistic(crate::index::Statistic::OrdinalRanges)
+        .statistic(crate::index::Statistic::SatRanges)
         .unwrap(),
       5,
     );
diff --git a/src/subcommand/server/templates.rs b/src/subcommand/server/templates.rs
index a6ff77690f..91993ceb0e 100644
--- a/src/subcommand/server/templates.rs
+++ b/src/subcommand/server/templates.rs
@@ -2,8 +2,8 @@ use {super::*, boilerplate::Boilerplate};
 
 pub(crate) use {
   block::BlockHtml, clock::ClockSvg, content::ContentHtml, home::HomeHtml, input::InputHtml,
-  inscription::InscriptionHtml, ordinal::OrdinalHtml, output::OutputHtml, range::RangeHtml,
-  rare::RareTxt, transaction::TransactionHtml,
+  inscription::InscriptionHtml, output::OutputHtml, range::RangeHtml, rare::RareTxt, sat::SatHtml,
+  transaction::TransactionHtml,
 };
 
 mod block;
@@ -12,10 +12,10 @@ mod content;
 mod home;
 mod input;
 mod inscription;
-mod ordinal;
 mod output;
 mod range;
 mod rare;
+mod sat;
 mod transaction;
 
 #[derive(Boilerplate)]
diff --git a/src/subcommand/server/templates/home.rs b/src/subcommand/server/templates/home.rs
index d6a5e9529b..7b3c3e7b4d 100644
--- a/src/subcommand/server/templates/home.rs
+++ b/src/subcommand/server/templates/home.rs
@@ -4,15 +4,15 @@ use super::*;
 pub(crate) struct HomeHtml {
   last: u64,
   blocks: Vec<BlockHash>,
-  starting_ordinal: Option<Ordinal>,
+  starting_sat: Option<Sat>,
 }
 
 impl HomeHtml {
   pub(crate) fn new(blocks: Vec<(u64, BlockHash)>) -> Self {
     Self {
-      starting_ordinal: blocks
+      starting_sat: blocks
         .get(0)
-        .map(|(height, _)| Height(*height).starting_ordinal()),
+        .map(|(height, _)| Height(*height).starting_sat()),
       last: blocks
         .get(0)
         .map(|(height, _)| height)
diff --git a/src/subcommand/server/templates/output.rs b/src/subcommand/server/templates/output.rs
index 9b5a43aea3..7a20d55590 100644
--- a/src/subcommand/server/templates/output.rs
+++ b/src/subcommand/server/templates/output.rs
@@ -43,9 +43,9 @@ mod tests {
           <dt>script pubkey</dt><dd class=data>OP_DUP OP_HASH160 OP_PUSHBYTES_20 0000000000000000000000000000000000000000 OP_EQUALVERIFY OP_CHECKSIG</dd>
           <dt>address</dt><dd class=monospace>1111111111111111111114oLvT2</dd>
         </dl>
-        <h2>2 Ordinal Ranges</h2>
+        <h2>2 Sat Ranges</h2>
         <ul class=monospace>
-          <li><a href=/ordinal/0 class=mythic>0</a></li>
+          <li><a href=/sat/0 class=mythic>0</a></li>
           <li><a href=/range/1/3 class=common>1–3</a></li>
         </ul>
       "
diff --git a/src/subcommand/server/templates/range.rs b/src/subcommand/server/templates/range.rs
index 80f08951a7..2b575ce7bd 100644
--- a/src/subcommand/server/templates/range.rs
+++ b/src/subcommand/server/templates/range.rs
@@ -2,13 +2,13 @@ use super::*;
 
 #[derive(Boilerplate)]
 pub(crate) struct RangeHtml {
-  pub(crate) start: Ordinal,
-  pub(crate) end: Ordinal,
+  pub(crate) start: Sat,
+  pub(crate) end: Sat,
 }
 
 impl PageContent for RangeHtml {
   fn title(&self) -> String {
-    format!("Ordinal range {}–{}", self.start, self.end)
+    format!("Sat range {}–{}", self.start, self.end)
   }
 }
 
@@ -20,15 +20,15 @@ mod tests {
   fn range_html() {
     pretty_assert_eq!(
       RangeHtml {
-        start: Ordinal(0),
-        end: Ordinal(1),
+        start: Sat(0),
+        end: Sat(1),
       }
       .to_string(),
       "
-        <h1>Ordinal range 0–1</h1>
+        <h1>Sat range 0–1</h1>
         <dl>
           <dt>value</dt><dd>1</dd>
-          <dt>first</dt><dd><a href=/ordinal/0 class=mythic>0</a></dd>
+          <dt>first</dt><dd><a href=/sat/0 class=mythic>0</a></dd>
         </dl>
       "
       .unindent()
@@ -39,15 +39,15 @@ mod tests {
   fn bugfix_broken_link() {
     pretty_assert_eq!(
       RangeHtml {
-        start: Ordinal(1),
-        end: Ordinal(10),
+        start: Sat(1),
+        end: Sat(10),
       }
       .to_string(),
       "
-        <h1>Ordinal range 1–10</h1>
+        <h1>Sat range 1–10</h1>
         <dl>
           <dt>value</dt><dd>9</dd>
-          <dt>first</dt><dd><a href=/ordinal/1 class=common>1</a></dd>
+          <dt>first</dt><dd><a href=/sat/1 class=common>1</a></dd>
         </dl>
       "
       .unindent()
diff --git a/src/subcommand/server/templates/rare.rs b/src/subcommand/server/templates/rare.rs
index 14ce242b97..24bbc1466d 100644
--- a/src/subcommand/server/templates/rare.rs
+++ b/src/subcommand/server/templates/rare.rs
@@ -1,4 +1,4 @@
 use super::*;
 
 #[derive(Boilerplate)]
-pub(crate) struct RareTxt(pub(crate) Vec<(Ordinal, SatPoint)>);
+pub(crate) struct RareTxt(pub(crate) Vec<(Sat, SatPoint)>);
diff --git a/src/subcommand/server/templates/ordinal.rs b/src/subcommand/server/templates/sat.rs
similarity index 81%
rename from src/subcommand/server/templates/ordinal.rs
rename to src/subcommand/server/templates/sat.rs
index d1878da1ad..a6105a3869 100644
--- a/src/subcommand/server/templates/ordinal.rs
+++ b/src/subcommand/server/templates/sat.rs
@@ -1,15 +1,15 @@
 use super::*;
 
 #[derive(Boilerplate)]
-pub(crate) struct OrdinalHtml {
-  pub(crate) ordinal: Ordinal,
+pub(crate) struct SatHtml {
+  pub(crate) sat: Sat,
   pub(crate) blocktime: Blocktime,
   pub(crate) inscription: Option<Inscription>,
 }
 
-impl PageContent for OrdinalHtml {
+impl PageContent for SatHtml {
   fn title(&self) -> String {
-    self.ordinal.degree().to_string()
+    self.sat.degree().to_string()
   }
 }
 
@@ -18,16 +18,16 @@ mod tests {
   use super::*;
 
   #[test]
-  fn ordinal_html() {
+  fn sat_html() {
     pretty_assert_eq!(
-      OrdinalHtml {
-        ordinal: Ordinal(0),
+      SatHtml {
+        sat: Sat(0),
         blocktime: Blocktime::Confirmed(0),
         inscription: None,
       }
       .to_string(),
       "
-        <h1>Ordinal 0</h1>
+        <h1>Sat 0</h1>
         <dl>
           <dt>decimal</dt><dd>0.0</dd>
           <dt>degree</dt><dd>0°0′0″0‴</dd>
@@ -42,23 +42,23 @@ mod tests {
           <dt>time</dt><dd>1970-01-01 00:00:00</dd>
         </dl>
         prev
-        <a href=/ordinal/1>next</a>
+        <a href=/sat/1>next</a>
       "
       .unindent()
     );
   }
 
   #[test]
-  fn ordinal_next_and_previous() {
+  fn sat_next_and_previous() {
     pretty_assert_eq!(
-      OrdinalHtml {
-        ordinal: Ordinal(1),
+      SatHtml {
+        sat: Sat(1),
         blocktime: Blocktime::Confirmed(0),
         inscription: None,
       }
       .to_string(),
       "
-        <h1>Ordinal 1</h1>
+        <h1>Sat 1</h1>
         <dl>
           <dt>decimal</dt><dd>0.1</dd>
           <dt>degree</dt><dd>0°0′0″1‴</dd>
@@ -72,24 +72,24 @@ mod tests {
           <dt>rarity</dt><dd><span class=common>common</span></dd>
           <dt>time</dt><dd>1970-01-01 00:00:00</dd>
         </dl>
-        <a href=/ordinal/0>prev</a>
-        <a href=/ordinal/2>next</a>
+        <a href=/sat/0>prev</a>
+        <a href=/sat/2>next</a>
       "
       .unindent()
     );
   }
 
   #[test]
-  fn ordinal_with_inscription() {
+  fn sat_with_inscription() {
     pretty_assert_eq!(
-      OrdinalHtml {
-        ordinal: Ordinal(0),
+      SatHtml {
+        sat: Sat(0),
         blocktime: Blocktime::Confirmed(0),
         inscription: Some(inscription("text/plain;charset=utf-8", "HELLOWORLD")),
       }
       .to_string(),
       "
-        <h1>Ordinal 0</h1>
+        <h1>Sat 0</h1>
         <dl>
           <dt>decimal</dt><dd>0.0</dd>
           <dt>degree</dt><dd>0°0′0″0‴</dd>
@@ -106,17 +106,17 @@ mod tests {
           <dd>HELLOWORLD</dd>
         </dl>
         prev
-        <a href=/ordinal/1>next</a>
+        <a href=/sat/1>next</a>
       "
       .unindent()
     );
   }
 
   #[test]
-  fn ordinal_inscriptions_are_escaped() {
+  fn sat_inscriptions_are_escaped() {
     pretty_assert_eq!(
-      OrdinalHtml {
-        ordinal: Ordinal(0),
+      SatHtml {
+        sat: Sat(0),
         blocktime: Blocktime::Confirmed(0),
         inscription: Some(inscription(
           "text/plain;charset=utf-8",
@@ -125,7 +125,7 @@ mod tests {
       }
       .to_string(),
       "
-        <h1>Ordinal 0</h1>
+        <h1>Sat 0</h1>
         <dl>
           <dt>decimal</dt><dd>0.0</dd>
           <dt>degree</dt><dd>0°0′0″0‴</dd>
@@ -142,23 +142,23 @@ mod tests {
           <dd>&lt;script&gt;alert(&apos;HELLOWORLD&apos;);&lt;/script&gt;</dd>
         </dl>
         prev
-        <a href=/ordinal/1>next</a>
+        <a href=/sat/1>next</a>
       "
       .unindent()
     );
   }
 
   #[test]
-  fn last_ordinal_next_link_is_disabled() {
+  fn last_sat_next_link_is_disabled() {
     pretty_assert_eq!(
-      OrdinalHtml {
-        ordinal: Ordinal::LAST,
+      SatHtml {
+        sat: Sat::LAST,
         blocktime: Blocktime::Confirmed(0),
         inscription: None,
       }
       .to_string(),
       "
-        <h1>Ordinal 2099999997689999</h1>
+        <h1>Sat 2099999997689999</h1>
         <dl>
           <dt>decimal</dt><dd>6929999.0</dd>
           <dt>degree</dt><dd>5°209999′1007″0‴</dd>
@@ -172,7 +172,7 @@ mod tests {
           <dt>rarity</dt><dd><span class=uncommon>uncommon</span></dd>
           <dt>time</dt><dd>1970-01-01 00:00:00</dd>
         </dl>
-        <a href=/ordinal/2099999997689998>prev</a>
+        <a href=/sat/2099999997689998>prev</a>
         next
       "
       .unindent()
diff --git a/src/subcommand/subsidy.rs b/src/subcommand/subsidy.rs
index 1c25985f1e..6eb2fe47b7 100644
--- a/src/subcommand/subsidy.rs
+++ b/src/subcommand/subsidy.rs
@@ -2,13 +2,13 @@ use super::*;
 
 #[derive(Debug, Parser)]
 pub(crate) struct Subsidy {
-  #[clap(help = "List ordinals in subsidy at <HEIGHT>.")]
+  #[clap(help = "List sats in subsidy at <HEIGHT>.")]
   height: Height,
 }
 
 impl Subsidy {
   pub(crate) fn run(self) -> Result {
-    let first = self.height.starting_ordinal();
+    let first = self.height.starting_sat();
 
     let subsidy = self.height.subsidy();
 
diff --git a/src/subcommand/supply.rs b/src/subcommand/supply.rs
index a988b97c0d..801bc744d2 100644
--- a/src/subcommand/supply.rs
+++ b/src/subcommand/supply.rs
@@ -10,9 +10,9 @@ pub(crate) fn run() -> Result {
     last += 1;
   }
 
-  println!("supply: {}", Ordinal::SUPPLY);
+  println!("supply: {}", Sat::SUPPLY);
   println!("first: {}", 0);
-  println!("last: {}", Ordinal::SUPPLY - 1);
+  println!("last: {}", Sat::SUPPLY - 1);
   println!("last mined in block: {}", last);
 
   Ok(())
diff --git a/src/subcommand/traits.rs b/src/subcommand/traits.rs
index 5db47b4650..455f01f41c 100644
--- a/src/subcommand/traits.rs
+++ b/src/subcommand/traits.rs
@@ -2,8 +2,8 @@ use super::*;
 
 #[derive(Debug, Parser)]
 pub(crate) struct Traits {
-  #[clap(help = "Show traits for <ORDINAL>.")]
-  ordinal: Ordinal,
+  #[clap(help = "Show traits for <SAT>.")]
+  sat: Sat,
 }
 
 impl Traits {
@@ -15,16 +15,16 @@ impl Traits {
 
 impl Display for Traits {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-    writeln!(f, "number: {}", self.ordinal.n())?;
-    writeln!(f, "decimal: {}", self.ordinal.decimal())?;
-    writeln!(f, "degree: {}", self.ordinal.degree())?;
-    writeln!(f, "name: {}", self.ordinal.name())?;
-    writeln!(f, "height: {}", self.ordinal.height())?;
-    writeln!(f, "cycle: {}", self.ordinal.cycle())?;
-    writeln!(f, "epoch: {}", self.ordinal.epoch())?;
-    writeln!(f, "period: {}", self.ordinal.period())?;
-    writeln!(f, "offset: {}", self.ordinal.third())?;
-    writeln!(f, "rarity: {}", self.ordinal.rarity())?;
+    writeln!(f, "number: {}", self.sat.n())?;
+    writeln!(f, "decimal: {}", self.sat.decimal())?;
+    writeln!(f, "degree: {}", self.sat.degree())?;
+    writeln!(f, "name: {}", self.sat.name())?;
+    writeln!(f, "height: {}", self.sat.height())?;
+    writeln!(f, "cycle: {}", self.sat.cycle())?;
+    writeln!(f, "epoch: {}", self.sat.epoch())?;
+    writeln!(f, "period: {}", self.sat.period())?;
+    writeln!(f, "offset: {}", self.sat.third())?;
+    writeln!(f, "rarity: {}", self.sat.rarity())?;
     Ok(())
   }
 }
@@ -36,10 +36,7 @@ mod tests {
   #[test]
   fn first() {
     assert_eq!(
-      Traits {
-        ordinal: Ordinal(0)
-      }
-      .to_string(),
+      Traits { sat: Sat(0) }.to_string(),
       "\
 number: 0
 decimal: 0.0
@@ -59,7 +56,7 @@ rarity: mythic
   fn last() {
     assert_eq!(
       Traits {
-        ordinal: Ordinal(2099999997689999)
+        sat: Sat(2099999997689999)
       }
       .to_string(),
       "\
diff --git a/src/subcommand/wallet.rs b/src/subcommand/wallet.rs
index fc87a376ee..47b3c75c9d 100644
--- a/src/subcommand/wallet.rs
+++ b/src/subcommand/wallet.rs
@@ -54,7 +54,7 @@ fn list_unspent(options: &Options, index: &Index) -> Result<Vec<(OutPoint, Vec<(
     .map(|utxo| {
       let outpoint = OutPoint::new(utxo.txid, utxo.vout);
       match index.list(outpoint)? {
-        Some(List::Unspent(ordinal_ranges)) => Ok((outpoint, ordinal_ranges)),
+        Some(List::Unspent(sat_ranges)) => Ok((outpoint, sat_ranges)),
         Some(List::Spent) => bail!("output {outpoint} in wallet but is spent according to index"),
         None => bail!("index has not seen {outpoint}"),
       }
diff --git a/src/subcommand/wallet/inscribe.rs b/src/subcommand/wallet/inscribe.rs
index d7c6948627..54026552b4 100644
--- a/src/subcommand/wallet/inscribe.rs
+++ b/src/subcommand/wallet/inscribe.rs
@@ -20,7 +20,7 @@ use {
 pub(crate) struct Inscribe {
   #[clap(long, help = "Inscribe <SATPOINT>")]
   satpoint: Option<SatPoint>,
-  #[clap(long, help = "Inscribe ordinal with contents of <FILE>")]
+  #[clap(long, help = "Inscribe sat with contents of <FILE>")]
   file: PathBuf,
 }
 
@@ -84,16 +84,15 @@ impl Inscribe {
       satpoint
     } else {
       let inscribed_utxos = inscriptions
-        .iter()
-        .map(|(satpoint, _)| satpoint.outpoint)
+        .keys()
+        .map(|satpoint| satpoint.outpoint)
         .collect::<BTreeSet<OutPoint>>();
 
       utxos
-        .iter()
-        .map(|(outpoint, _)| *outpoint)
+        .keys()
         .find(|outpoint| !inscribed_utxos.contains(outpoint))
         .map(|outpoint| SatPoint {
-          outpoint,
+          outpoint: *outpoint,
           offset: 0,
         })
         .ok_or_else(|| anyhow!("wallet contains no cardinal utxos"))?
@@ -147,7 +146,7 @@ impl Inscribe {
       .iter()
       .enumerate()
       .find(|(_vout, output)| output.script_pubkey == commit_tx_address.script_pubkey())
-      .expect("should find ordinal commit/inscription output");
+      .expect("should find sat commit/inscription output");
 
     let mut reveal_tx = Transaction {
       input: vec![TxIn {
diff --git a/src/subcommand/wallet/satoshis.rs b/src/subcommand/wallet/satoshis.rs
index 7d7d9f142c..51cb51ef7e 100644
--- a/src/subcommand/wallet/satoshis.rs
+++ b/src/subcommand/wallet/satoshis.rs
@@ -17,16 +17,16 @@ impl Satoshis {
     let utxos = list_unspent(&options, &index)?;
 
     if let Some(path) = &self.tsv {
-      for (output, ordinal) in satoshis_from_tsv(
+      for (output, sat) in satoshis_from_tsv(
         utxos,
         &fs::read_to_string(path)
           .with_context(|| format!("I/O error reading `{}`", path.display()))?,
       )? {
-        println!("{output}\t{ordinal}");
+        println!("{output}\t{sat}");
       }
     } else {
-      for (output, ordinal, offset, rarity) in rare_satoshis(utxos) {
-        println!("{output}\t{ordinal}\t{offset}\t{rarity}");
+      for (output, sat, offset, rarity) in rare_satoshis(utxos) {
+        println!("{output}\t{sat}\t{offset}\t{rarity}");
       }
     }
 
@@ -34,18 +34,18 @@ impl Satoshis {
   }
 }
 
-fn rare_satoshis(utxos: Vec<(OutPoint, Vec<(u64, u64)>)>) -> Vec<(OutPoint, Ordinal, u64, Rarity)> {
+fn rare_satoshis(utxos: Vec<(OutPoint, Vec<(u64, u64)>)>) -> Vec<(OutPoint, Sat, u64, Rarity)> {
   utxos
     .into_iter()
-    .flat_map(|(outpoint, ordinal_ranges)| {
+    .flat_map(|(outpoint, sat_ranges)| {
       let mut offset = 0;
-      ordinal_ranges.into_iter().filter_map(move |(start, end)| {
-        let ordinal = Ordinal(start);
-        let rarity = ordinal.rarity();
+      sat_ranges.into_iter().filter_map(move |(start, end)| {
+        let sat = Sat(start);
+        let rarity = sat.rarity();
         let start_offset = offset;
         offset += end - start;
         if rarity > Rarity::Common {
-          Some((outpoint, ordinal, start_offset, rarity))
+          Some((outpoint, sat, start_offset, rarity))
         } else {
           None
         }
@@ -65,14 +65,14 @@ fn satoshis_from_tsv(
     }
 
     if let Some(value) = line.split('\t').next() {
-      let ordinal = Ordinal::from_str(value).map_err(|err| {
+      let sat = Sat::from_str(value).map_err(|err| {
         anyhow!(
-          "failed to parse ordinal from string \"{value}\" on line {}: {err}",
+          "failed to parse sat from string \"{value}\" on line {}: {err}",
           i + 1,
         )
       })?;
 
-      needles.push((ordinal, value));
+      needles.push((sat, value));
     }
   }
   needles.sort();
@@ -113,7 +113,7 @@ mod tests {
   use {super::*, std::fmt::Write};
 
   #[test]
-  fn identify_no_rare_ordinals() {
+  fn identify_no_rare_sats() {
     assert_eq!(
       rare_satoshis(vec![(
         outpoint(1),
@@ -124,40 +124,40 @@ mod tests {
   }
 
   #[test]
-  fn identify_one_rare_ordinal() {
+  fn identify_one_rare_sat() {
     assert_eq!(
       rare_satoshis(vec![(
         outpoint(1),
         vec![(10, 80), (50 * COIN_VALUE, 100 * COIN_VALUE)],
       )]),
-      vec![(outpoint(1), Ordinal(50 * COIN_VALUE), 70, Rarity::Uncommon)]
+      vec![(outpoint(1), Sat(50 * COIN_VALUE), 70, Rarity::Uncommon)]
     )
   }
 
   #[test]
-  fn identify_two_rare_ordinals() {
+  fn identify_two_rare_sats() {
     assert_eq!(
       rare_satoshis(vec![(
         outpoint(1),
         vec![(0, 100), (1050000000000000, 1150000000000000)],
       )]),
       vec![
-        (outpoint(1), Ordinal(0), 0, Rarity::Mythic),
-        (outpoint(1), Ordinal(1050000000000000), 100, Rarity::Epic)
+        (outpoint(1), Sat(0), 0, Rarity::Mythic),
+        (outpoint(1), Sat(1050000000000000), 100, Rarity::Epic)
       ]
     )
   }
 
   #[test]
-  fn identify_rare_ordinals_in_different_outpoints() {
+  fn identify_rare_sats_in_different_outpoints() {
     assert_eq!(
       rare_satoshis(vec![
         (outpoint(1), vec![(50 * COIN_VALUE, 55 * COIN_VALUE)]),
         (outpoint(2), vec![(100 * COIN_VALUE, 111 * COIN_VALUE)],),
       ]),
       vec![
-        (outpoint(1), Ordinal(50 * COIN_VALUE), 0, Rarity::Uncommon),
-        (outpoint(2), Ordinal(100 * COIN_VALUE), 0, Rarity::Uncommon)
+        (outpoint(1), Sat(50 * COIN_VALUE), 0, Rarity::Uncommon),
+        (outpoint(2), Sat(100 * COIN_VALUE), 0, Rarity::Uncommon)
       ]
     )
   }
@@ -252,7 +252,7 @@ mod tests {
       satoshis_from_tsv(vec![(outpoint(1), vec![(0, 1)])], "0\n===\n")
         .unwrap_err()
         .to_string(),
-      "failed to parse ordinal from string \"===\" on line 2: invalid digit found in string",
+      "failed to parse sat from string \"===\" on line 2: invalid digit found in string",
     )
   }
 
diff --git a/src/subcommand/wallet/transaction_builder.rs b/src/subcommand/wallet/transaction_builder.rs
index 6345f4767c..40ab1d9925 100644
--- a/src/subcommand/wallet/transaction_builder.rs
+++ b/src/subcommand/wallet/transaction_builder.rs
@@ -10,7 +10,7 @@
 //!
 //! The external interface is `TransactionBuilder::build_transaction`, which
 //! returns a constructed transaction given the arguments, which include the
-//! ordinal to send, the wallets current UTXOs and their ordinal ranges, and
+//! outgoing sat to send, the wallets current UTXOs and their sat ranges, and
 //! the recipient's address.
 //!
 //! Internally, `TransactionBuilder` calls multiple methods that implement
@@ -46,7 +46,7 @@ pub(crate) enum Error {
 impl fmt::Display for Error {
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     match self {
-      Error::NotInWallet(satpoint) => write!(f, "satpoint {satpoint} not in wallet"),
+      Error::NotInWallet(outgoing_satpoint) => write!(f, "outgoing satpoint {outgoing_satpoint} not in wallet"),
       Error::NotEnoughCardinalUtxos => write!(
         f,
         "wallet does not contain enough cardinal UTXOs, please add additional funds to wallet."
@@ -73,7 +73,7 @@ pub(crate) struct TransactionBuilder {
   inscriptions: BTreeMap<SatPoint, InscriptionId>,
   outputs: Vec<(Address, Amount)>,
   recipient: Address,
-  satpoint: SatPoint,
+  outgoing: SatPoint,
   unused_change_addresses: Vec<Address>,
   utxos: BTreeSet<OutPoint>,
 }
@@ -86,15 +86,15 @@ impl TransactionBuilder {
   const TARGET_POSTAGE: Amount = Amount::from_sat(10_000);
 
   pub(crate) fn build_transaction(
-    satpoint: SatPoint,
+    outgoing: SatPoint,
     inscriptions: BTreeMap<SatPoint, InscriptionId>,
     amounts: BTreeMap<OutPoint, Amount>,
     recipient: Address,
     change: Vec<Address>,
   ) -> Result<Transaction> {
-    Self::new(satpoint, inscriptions, amounts, recipient, change)
-      .select_ordinal()?
-      .align_ordinal()
+    Self::new(outgoing, inscriptions, amounts, recipient, change)
+      .select_outgoing()?
+      .align_outgoing()
       .pad_alignment_output()?
       .add_postage()?
       .strip_excess_postage()
@@ -103,7 +103,7 @@ impl TransactionBuilder {
   }
 
   fn new(
-    satpoint: SatPoint,
+    outgoing: SatPoint,
     inscriptions: BTreeMap<SatPoint, InscriptionId>,
     amounts: BTreeMap<OutPoint, Amount>,
     recipient: Address,
@@ -117,38 +117,38 @@ impl TransactionBuilder {
       inscriptions,
       outputs: Vec::new(),
       recipient,
-      satpoint,
+      outgoing,
       unused_change_addresses: change,
     }
   }
 
-  fn select_ordinal(mut self) -> Result<Self> {
+  fn select_outgoing(mut self) -> Result<Self> {
     for (inscribed_satpoint, inscription_id) in &self.inscriptions {
-      if self.satpoint.outpoint == inscribed_satpoint.outpoint
-        && self.satpoint.offset != inscribed_satpoint.offset
+      if self.outgoing.outpoint == inscribed_satpoint.outpoint
+        && self.outgoing.offset != inscribed_satpoint.offset
       {
         return Err(Error::UtxoContainsAdditionalInscription {
-          outgoing_satpoint: self.satpoint,
+          outgoing_satpoint: self.outgoing,
           inscribed_satpoint: *inscribed_satpoint,
           inscription_id: *inscription_id,
         });
       }
     }
 
-    self.utxos.remove(&self.satpoint.outpoint);
-    self.inputs.push(self.satpoint.outpoint);
+    self.utxos.remove(&self.outgoing.outpoint);
+    self.inputs.push(self.outgoing.outpoint);
     self.outputs.push((
       self.recipient.clone(),
       *self
         .amounts
-        .get(&self.satpoint.outpoint)
-        .ok_or(Error::NotInWallet(self.satpoint))?,
+        .get(&self.outgoing.outpoint)
+        .ok_or(Error::NotInWallet(self.outgoing))?,
     ));
 
     Ok(self)
   }
 
-  fn align_ordinal(mut self) -> Self {
+  fn align_outgoing(mut self) -> Self {
     assert_eq!(self.outputs.len(), 1, "invariant: only one output");
 
     assert_eq!(
@@ -156,8 +156,8 @@ impl TransactionBuilder {
       "invariant: first output is recipient"
     );
 
-    let ordinal_offset = self.calculate_ordinal_offset();
-    if ordinal_offset != 0 {
+    let sat_offset = self.calculate_sat_offset();
+    if sat_offset != 0 {
       self.outputs.insert(
         0,
         (
@@ -165,10 +165,10 @@ impl TransactionBuilder {
             .unused_change_addresses
             .pop()
             .expect("not enough change addresses"),
-          Amount::from_sat(ordinal_offset),
+          Amount::from_sat(sat_offset),
         ),
       );
-      self.outputs.last_mut().expect("no output").1 -= Amount::from_sat(ordinal_offset);
+      self.outputs.last_mut().expect("no output").1 -= Amount::from_sat(sat_offset);
     }
 
     self
@@ -201,7 +201,7 @@ impl TransactionBuilder {
   }
 
   fn strip_excess_postage(mut self) -> Self {
-    let ordinal_offset = self.calculate_ordinal_offset();
+    let sat_offset = self.calculate_sat_offset();
     let total_output_amount = self
       .outputs
       .iter()
@@ -214,7 +214,7 @@ impl TransactionBuilder {
       .position(|(address, _amount)| address == &self.recipient)
       .expect("couldn't find output that contains the index");
 
-    let postage = total_output_amount - Amount::from_sat(ordinal_offset);
+    let postage = total_output_amount - Amount::from_sat(sat_offset);
     if postage > Self::MAX_POSTAGE {
       self.outputs.last_mut().expect("no outputs found").1 = Self::TARGET_POSTAGE;
       self.outputs.push((
@@ -230,7 +230,7 @@ impl TransactionBuilder {
   }
 
   fn deduct_fee(mut self) -> Self {
-    let ordinal_offset = self.calculate_ordinal_offset();
+    let sat_offset = self.calculate_sat_offset();
 
     let fee = self.estimate_fee();
 
@@ -246,8 +246,8 @@ impl TransactionBuilder {
       .expect("No output to deduct fee from");
 
     assert!(
-      total_output_amount - fee > Amount::from_sat(ordinal_offset) && *last_output_amount >= fee,
-      "invariant: deducting fee does not consume ordinal",
+      total_output_amount - fee > Amount::from_sat(sat_offset) && *last_output_amount >= fee,
+      "invariant: deducting fee does not consume sat",
     );
 
     *last_output_amount -= fee;
@@ -323,50 +323,50 @@ impl TransactionBuilder {
       self
         .amounts
         .iter()
-        .filter(|(outpoint, amount)| *outpoint == &self.satpoint.outpoint
-          && self.satpoint.offset < amount.to_sat())
+        .filter(|(outpoint, amount)| *outpoint == &self.outgoing.outpoint
+          && self.outgoing.offset < amount.to_sat())
         .count(),
       1,
-      "invariant: satpoint is contained in utxos"
+      "invariant: outgoing sat is contained in utxos"
     );
 
     assert_eq!(
       transaction
         .input
         .iter()
-        .filter(|tx_in| tx_in.previous_output == self.satpoint.outpoint)
+        .filter(|tx_in| tx_in.previous_output == self.outgoing.outpoint)
         .count(),
       1,
-      "invariant: inputs spend ordinal"
+      "invariant: inputs spend outgoing sat"
     );
 
-    let mut ordinal_offset = 0;
+    let mut sat_offset = 0;
     let mut found = false;
     for tx_in in &transaction.input {
-      if tx_in.previous_output == self.satpoint.outpoint {
-        ordinal_offset += self.satpoint.offset;
+      if tx_in.previous_output == self.outgoing.outpoint {
+        sat_offset += self.outgoing.offset;
         found = true;
         break;
       } else {
-        ordinal_offset += self.amounts[&tx_in.previous_output].to_sat();
+        sat_offset += self.amounts[&tx_in.previous_output].to_sat();
       }
     }
-    assert!(found, "invariant: satpoint is found in inputs");
+    assert!(found, "invariant: outgoing sat is found in inputs");
 
     let mut output_end = 0;
     let mut found = false;
     for tx_out in &transaction.output {
       output_end += tx_out.value;
-      if output_end > ordinal_offset {
+      if output_end > sat_offset {
         assert_eq!(
           tx_out.script_pubkey, recipient,
-          "invariant: ordinal is sent to recipient"
+          "invariant: outgoing sat is sent to recipient"
         );
         found = true;
         break;
       }
     }
-    assert!(found, "invariant: ordinal is found in outputs");
+    assert!(found, "invariant: outgoing sat is found in outputs");
 
     assert_eq!(
       transaction
@@ -399,8 +399,8 @@ impl TransactionBuilder {
           "invariant: excess postage is stripped"
         );
         assert_eq!(
-          offset, ordinal_offset,
-          "invariant: ordinal is at first position in recipient output"
+          offset, sat_offset,
+          "invariant: sat is at first position in recipient output"
         );
       } else {
         assert!(
@@ -442,17 +442,17 @@ impl TransactionBuilder {
     Ok(transaction)
   }
 
-  fn calculate_ordinal_offset(&self) -> u64 {
-    let mut ordinal_offset = 0;
+  fn calculate_sat_offset(&self) -> u64 {
+    let mut sat_offset = 0;
     for outpoint in &self.inputs {
-      if *outpoint == self.satpoint.outpoint {
-        return ordinal_offset + self.satpoint.offset;
+      if *outpoint == self.outgoing.outpoint {
+        return sat_offset + self.outgoing.offset;
       } else {
-        ordinal_offset += self.amounts[outpoint].to_sat();
+        sat_offset += self.amounts[outpoint].to_sat();
       }
     }
 
-    panic!("Could not find satpoint in inputs");
+    panic!("Could not find outgoing sat in inputs");
   }
 
   fn select_cardinal_utxo(&mut self, minimum_amount: Amount) -> Result<(OutPoint, Amount)> {
@@ -460,8 +460,8 @@ impl TransactionBuilder {
 
     let inscribed_utxos = self
       .inscriptions
-      .iter()
-      .map(|(satpoint, _inscription_id)| satpoint.outpoint)
+      .keys()
+      .map(|satpoint| satpoint.outpoint)
       .collect::<BTreeSet<OutPoint>>();
 
     for utxo in &self.utxos {
@@ -490,7 +490,7 @@ mod tests {
   use {super::Error, super::*};
 
   #[test]
-  fn select_ordinal() {
+  fn select_sat() {
     let mut utxos = vec![
       (outpoint(1), Amount::from_sat(5_000)),
       (outpoint(2), Amount::from_sat(49 * COIN_VALUE)),
@@ -504,7 +504,7 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap();
 
     utxos.remove(1);
@@ -532,7 +532,7 @@ mod tests {
     let tx_builder = TransactionBuilder {
       amounts,
       utxos: BTreeSet::new(),
-      satpoint: satpoint(1, 0),
+      outgoing: satpoint(1, 0),
       inscriptions: BTreeMap::new(),
       recipient: recipient(),
       unused_change_addresses: vec![change(0), change(1)],
@@ -597,8 +597,8 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: deducting fee does not consume ordinal")]
-  fn invariant_deduct_fee_does_not_consume_ordinal() {
+  #[should_panic(expected = "invariant: deducting fee does not consume sat")]
+  fn invariant_deduct_fee_does_not_consume_sat() {
     let utxos = vec![(outpoint(1), Amount::from_sat(5_000))];
 
     TransactionBuilder::new(
@@ -608,9 +608,9 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap()
-    .align_ordinal()
+    .align_outgoing()
     .strip_excess_postage()
     .deduct_fee();
   }
@@ -703,7 +703,7 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: satpoint is contained in utxos")]
+  #[should_panic(expected = "invariant: outgoing sat is contained in utxos")]
   fn invariant_satpoint_outpoint_is_contained_in_utxos() {
     TransactionBuilder::new(
       satpoint(2, 0),
@@ -719,7 +719,7 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: satpoint is contained in utxos")]
+  #[should_panic(expected = "invariant: outgoing sat is contained in utxos")]
   fn invariant_satpoint_offset_is_contained_in_utxos() {
     TransactionBuilder::new(
       satpoint(1, 4),
@@ -735,8 +735,8 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: inputs spend ordinal")]
-  fn invariant_inputs_spend_ordinal() {
+  #[should_panic(expected = "invariant: inputs spend outgoing sat")]
+  fn invariant_inputs_spend_sat() {
     TransactionBuilder::new(
       satpoint(1, 2),
       BTreeMap::new(),
@@ -751,8 +751,8 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: ordinal is sent to recipient")]
-  fn invariant_ordinal_is_sent_to_recipient() {
+  #[should_panic(expected = "invariant: outgoing sat is sent to recipient")]
+  fn invariant_sat_is_sent_to_recipient() {
     let mut builder = TransactionBuilder::new(
       satpoint(1, 2),
       BTreeMap::new(),
@@ -762,7 +762,7 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap();
 
     builder.outputs[0].0 = "tb1qx4gf3ya0cxfcwydpq8vr2lhrysneuj5d7lqatw"
@@ -773,8 +773,8 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: ordinal is found in outputs")]
-  fn invariant_ordinal_is_found_in_outputs() {
+  #[should_panic(expected = "invariant: outgoing sat is found in outputs")]
+  fn invariant_sat_is_found_in_outputs() {
     let mut builder = TransactionBuilder::new(
       satpoint(1, 2),
       BTreeMap::new(),
@@ -784,7 +784,7 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap();
 
     builder.outputs[0].1 = Amount::from_sat(0);
@@ -828,14 +828,14 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap()
     .build()
     .unwrap();
   }
 
   #[test]
-  fn ordinal_is_aligned() {
+  fn sat_is_aligned() {
     let utxos = vec![(outpoint(1), Amount::from_sat(10_000))];
 
     pretty_assert_eq!(
@@ -891,9 +891,9 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap()
-    .align_ordinal()
+    .align_outgoing()
     .add_postage()
     .unwrap()
     .strip_excess_postage()
@@ -916,9 +916,9 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap()
-    .align_ordinal()
+    .align_outgoing()
     .add_postage()
     .unwrap()
     .strip_excess_postage()
@@ -928,8 +928,8 @@ mod tests {
   }
 
   #[test]
-  #[should_panic(expected = "invariant: ordinal is at first position in recipient output")]
-  fn invariant_ordinal_is_aligned() {
+  #[should_panic(expected = "invariant: sat is at first position in recipient output")]
+  fn invariant_sat_is_aligned() {
     let utxos = vec![(outpoint(1), Amount::from_sat(10_000))];
 
     TransactionBuilder::new(
@@ -939,7 +939,7 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap()
     .strip_excess_postage()
     .deduct_fee()
@@ -959,7 +959,7 @@ mod tests {
       recipient(),
       vec![change(0), change(1)],
     )
-    .select_ordinal()
+    .select_outgoing()
     .unwrap()
     .strip_excess_postage()
     .build()
@@ -977,7 +977,7 @@ mod tests {
     TransactionBuilder {
       amounts,
       utxos: BTreeSet::new(),
-      satpoint: satpoint(1, 0),
+      outgoing: satpoint(1, 0),
       inscriptions: BTreeMap::new(),
       recipient: recipient(),
       unused_change_addresses: vec![change(0), change(1)],
@@ -1004,7 +1004,7 @@ mod tests {
     TransactionBuilder {
       amounts,
       utxos: BTreeSet::new(),
-      satpoint: satpoint(1, 0),
+      outgoing: satpoint(1, 0),
       inscriptions: BTreeMap::new(),
       recipient: recipient(),
       unused_change_addresses: vec![change(0), change(1)],
diff --git a/templates/clock.svg b/templates/clock.svg
index 8e16a8b83a..06a15e3043 100644
--- a/templates/clock.svg
+++ b/templates/clock.svg
@@ -14,39 +14,39 @@
   <circle r="4000" fill="#dedede" stroke="none"/>
   <circle r="19" stroke-width="0.2"/>
   <text y="4" dominant-baseline="middle" text-anchor="middle" stroke="none" font-size="4" fill="lightgrey">{{self.height}}</text>
-  <a href="/ordinal/0°0′0″0‴"><line class="mythic" y1="-16" y2="-15" stroke-width="0.3" stroke="#d00505"><title>Genesis</title></line></a>
-  <a href="/ordinal/0°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(10.90909090909091)"><title>1st Halving</title></line></a>
-  <a href="/ordinal/0°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(21.81818181818182)"><title>2nd Halving</title></line></a>
-  <a href="/ordinal/0°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(32.72727272727273)"><title>3rd Halving</title></line></a>
-  <a href="/ordinal/0°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(43.63636363636364)"><title>4th Halving</title></line></a>
-  <a href="/ordinal/0°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(54.54545454545455)"><title>5th Halving</title></line></a>
-  <a href="/ordinal/1°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(65.45454545454545)"><title>1st Conjunction</title></line></a>
-  <a href="/ordinal/1°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(76.36363636363636)"><title>7th Halving</title></line></a>
-  <a href="/ordinal/1°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(87.27272727272728)"><title>8th Halving</title></line></a>
-  <a href="/ordinal/1°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(98.18181818181817)"><title>9th Halving</title></line></a>
-  <a href="/ordinal/1°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(109.0909090909091)"><title>10th Halving</title></line></a>
-  <a href="/ordinal/1°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(120.0)"><title>11th Halving</title></line></a>
-  <a href="/ordinal/2°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(130.9090909090909)"><title>2nd Conjunction</title></line></a>
-  <a href="/ordinal/2°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(141.8181818181818)"><title>13th Halving</title></line></a>
-  <a href="/ordinal/2°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(152.72727272727272)"><title>14th Halving</title></line></a>
-  <a href="/ordinal/2°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(163.63636363636363)"><title>15th Halving</title></line></a>
-  <a href="/ordinal/2°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(174.54545454545456)"><title>16th Halving</title></line></a>
-  <a href="/ordinal/2°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(185.45454545454544)"><title>17th Halving</title></line></a>
-  <a href="/ordinal/3°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(196.36363636363635)"><title>3rd Conjunction</title></line></a>
-  <a href="/ordinal/3°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(207.27272727272728)"><title>19th Halving</title></line></a>
-  <a href="/ordinal/3°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(218.1818181818182)"><title>20th Halving</title></line></a>
-  <a href="/ordinal/3°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(229.0909090909091)"><title>21st Halving</title></line></a>
-  <a href="/ordinal/3°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(240.0)"><title>22nd Halving</title></line></a>
-  <a href="/ordinal/3°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(250.90909090909093)"><title>23rd Halving</title></line></a>
-  <a href="/ordinal/4°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(261.8181818181818)"><title>4th Conjunction</title></line></a>
-  <a href="/ordinal/4°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(272.72727272727275)"><title>25th Halving</title></line></a>
-  <a href="/ordinal/4°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(283.6363636363636)"><title>26th Halving</title></line></a>
-  <a href="/ordinal/4°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(294.54545454545456)"><title>27th Halving</title></line></a>
-  <a href="/ordinal/4°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(305.45454545454544)"><title>28th Halving</title></line></a>
-  <a href="/ordinal/4°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(316.3636363636364)"><title>29th Halving</title></line></a>
-  <a href="/ordinal/5°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(327.27272727272725)"><title>5th Conjunction</title></line></a>
-  <a href="/ordinal/5°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(338.1818181818182)"><title>31st Halving</title></line></a>
-  <a href="/ordinal/5°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(349.0909090909091)"><title>32nd Halving</title></line></a>
+  <a href="/sat/0°0′0″0‴"><line class="mythic" y1="-16" y2="-15" stroke-width="0.3" stroke="#d00505"><title>Genesis</title></line></a>
+  <a href="/sat/0°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(10.90909090909091)"><title>1st Halving</title></line></a>
+  <a href="/sat/0°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(21.81818181818182)"><title>2nd Halving</title></line></a>
+  <a href="/sat/0°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(32.72727272727273)"><title>3rd Halving</title></line></a>
+  <a href="/sat/0°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(43.63636363636364)"><title>4th Halving</title></line></a>
+  <a href="/sat/0°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(54.54545454545455)"><title>5th Halving</title></line></a>
+  <a href="/sat/1°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(65.45454545454545)"><title>1st Conjunction</title></line></a>
+  <a href="/sat/1°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(76.36363636363636)"><title>7th Halving</title></line></a>
+  <a href="/sat/1°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(87.27272727272728)"><title>8th Halving</title></line></a>
+  <a href="/sat/1°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(98.18181818181817)"><title>9th Halving</title></line></a>
+  <a href="/sat/1°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(109.0909090909091)"><title>10th Halving</title></line></a>
+  <a href="/sat/1°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(120.0)"><title>11th Halving</title></line></a>
+  <a href="/sat/2°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(130.9090909090909)"><title>2nd Conjunction</title></line></a>
+  <a href="/sat/2°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(141.8181818181818)"><title>13th Halving</title></line></a>
+  <a href="/sat/2°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(152.72727272727272)"><title>14th Halving</title></line></a>
+  <a href="/sat/2°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(163.63636363636363)"><title>15th Halving</title></line></a>
+  <a href="/sat/2°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(174.54545454545456)"><title>16th Halving</title></line></a>
+  <a href="/sat/2°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(185.45454545454544)"><title>17th Halving</title></line></a>
+  <a href="/sat/3°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(196.36363636363635)"><title>3rd Conjunction</title></line></a>
+  <a href="/sat/3°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(207.27272727272728)"><title>19th Halving</title></line></a>
+  <a href="/sat/3°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(218.1818181818182)"><title>20th Halving</title></line></a>
+  <a href="/sat/3°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(229.0909090909091)"><title>21st Halving</title></line></a>
+  <a href="/sat/3°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(240.0)"><title>22nd Halving</title></line></a>
+  <a href="/sat/3°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(250.90909090909093)"><title>23rd Halving</title></line></a>
+  <a href="/sat/4°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(261.8181818181818)"><title>4th Conjunction</title></line></a>
+  <a href="/sat/4°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(272.72727272727275)"><title>25th Halving</title></line></a>
+  <a href="/sat/4°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(283.6363636363636)"><title>26th Halving</title></line></a>
+  <a href="/sat/4°0′1008″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(294.54545454545456)"><title>27th Halving</title></line></a>
+  <a href="/sat/4°0′1344″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(305.45454545454544)"><title>28th Halving</title></line></a>
+  <a href="/sat/4°0′1680″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(316.3636363636364)"><title>29th Halving</title></line></a>
+  <a href="/sat/5°0′0″0‴"><line class="legendary" y1="-16" y2="-15" stroke-width="0.5" transform="rotate(327.27272727272725)"><title>5th Conjunction</title></line></a>
+  <a href="/sat/5°0′336″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(338.1818181818182)"><title>31st Halving</title></line></a>
+  <a href="/sat/5°0′672″0‴"><line class="epic" y1="-16" y2="-15" stroke-width="0.3" transform="rotate(349.0909090909091)"><title>32nd Halving</title></line></a>
   <line y2="-9" transform="rotate({{self.hour}})"><title>Subsidy</title></line>
   <line y2="-13" stroke-width="0.6" transform="rotate({{self.minute}})"><title>Epoch</title></line>
   <line y2="-16" stroke="#d00505" stroke-width="0.2" transform="rotate({{self.second}})"><title>Period</title></line>
diff --git a/templates/home.html b/templates/home.html
index ff8d79ae55..6b8c6ddc98 100644
--- a/templates/home.html
+++ b/templates/home.html
@@ -6,13 +6,13 @@ <h1>Bitcoin-native NFTs</h1>
 
 <p><a href=https://docs.ordinals.com>Get Started</a></p>
 
-%% if let Some(starting_ordinal) = self.starting_ordinal {
+%% if let Some(starting_sat) = self.starting_sat {
 <h2>Status</h2>
 <dl>
-  <dt>cycle</dt><dd>{{starting_ordinal.cycle()}}</dd>
-  <dt>epoch</dt><dd>{{starting_ordinal.epoch()}}</dd>
-  <dt>period</dt><dd>{{starting_ordinal.period()}}</dd>
-  <dt>block</dt><dd>{{starting_ordinal.height()}}</dd>
+  <dt>cycle</dt><dd>{{starting_sat.cycle()}}</dd>
+  <dt>epoch</dt><dd>{{starting_sat.epoch()}}</dd>
+  <dt>period</dt><dd>{{starting_sat.period()}}</dd>
+  <dt>block</dt><dd>{{starting_sat.height()}}</dd>
 </dl>
 %% }
 <h2>Latest Blocks</h2>
diff --git a/templates/ordinal.html b/templates/ordinal.html
deleted file mode 100644
index 3490ab6894..0000000000
--- a/templates/ordinal.html
+++ /dev/null
@@ -1,28 +0,0 @@
-<h1>Ordinal {{ self.ordinal.n() }}</h1>
-<dl>
-  <dt>decimal</dt><dd>{{ self.ordinal.decimal() }}</dd>
-  <dt>degree</dt><dd>{{ self.ordinal.degree() }}</dd>
-  <dt>percentile</dt><dd>{{ self.ordinal.percentile() }}</dd>
-  <dt>name</dt><dd>{{ self.ordinal.name() }}</dd>
-  <dt>cycle</dt><dd>{{ self.ordinal.cycle() }}</dd>
-  <dt>epoch</dt><dd>{{ self.ordinal.epoch() }}</dd>
-  <dt>period</dt><dd>{{ self.ordinal.period() }}</dd>
-  <dt>block</dt><dd>{{ self.ordinal.height() }}</dd>
-  <dt>offset</dt><dd>{{ self.ordinal.third() }}</dd>
-  <dt>rarity</dt><dd><span class={{self.ordinal.rarity()}}>{{ self.ordinal.rarity() }}</span></dd>
-  <dt>time</dt><dd>{{ self.blocktime }}</dd>
-%% if let Some(inscription) = &self.inscription {
-  <dt>inscription</dt>
-  <dd>{{ inscription.content_html() }}</dd>
-%% }
-</dl>
-%% if self.ordinal.n() > 0 {
-<a href=/ordinal/{{self.ordinal.n() - 1}}>prev</a>
-%% } else {
-prev
-%% }
-%% if self.ordinal < Ordinal::LAST {
-<a href=/ordinal/{{self.ordinal.n() + 1}}>next</a>
-%% } else {
-next
-%% }
diff --git a/templates/output.html b/templates/output.html
index 459577d729..5f052c12de 100644
--- a/templates/output.html
+++ b/templates/output.html
@@ -9,13 +9,13 @@ <h1>Output <span class=monospace>{{self.outpoint}}</span></h1>
 %% if let Some(list) = &self.list {
 %% match list {
 %% List::Unspent(ranges) => {
-<h2>{{"Ordinal Range".tally(ranges.len())}}</h2>
+<h2>{{"Sat Range".tally(ranges.len())}}</h2>
 <ul class=monospace>
 %% for (start, end) in ranges {
 %% if end - start == 1 {
-  <li><a href=/ordinal/{{start}} class={{Ordinal(*start).rarity()}}>{{start}}</a></li>
+  <li><a href=/sat/{{start}} class={{Sat(*start).rarity()}}>{{start}}</a></li>
 %% } else {
-  <li><a href=/range/{{start}}/{{end}} class={{Ordinal(*start).rarity()}}>{{start}}–{{end}}</a></li>
+  <li><a href=/range/{{start}}/{{end}} class={{Sat(*start).rarity()}}>{{start}}–{{end}}</a></li>
 %% }
 %% }
 </ul>
diff --git a/templates/range.html b/templates/range.html
index eda431542b..478bdb9cae 100644
--- a/templates/range.html
+++ b/templates/range.html
@@ -1,5 +1,5 @@
-<h1>Ordinal range {{self.start}}–{{self.end}}</h1>
+<h1>Sat range {{self.start}}–{{self.end}}</h1>
 <dl>
   <dt>value</dt><dd>{{self.end.n() - self.start.n()}}</dd>
-  <dt>first</dt><dd><a href=/ordinal/{{self.start.n()}} class={{self.start.rarity()}}>{{self.start.n()}}</a></dd>
+  <dt>first</dt><dd><a href=/sat/{{self.start.n()}} class={{self.start.rarity()}}>{{self.start.n()}}</a></dd>
 </dl>
diff --git a/templates/rare.txt b/templates/rare.txt
index 41d8afa3cc..2881870132 100644
--- a/templates/rare.txt
+++ b/templates/rare.txt
@@ -1,4 +1,4 @@
-ordinal	satpoint
-%% for (ordinal, satpoint) in &self.0 {
-{{ordinal}}	{{satpoint}}
+sat	satpoint
+%% for (sat, satpoint) in &self.0 {
+{{sat}}	{{satpoint}}
 %% }
diff --git a/templates/sat.html b/templates/sat.html
new file mode 100644
index 0000000000..1b5772a9cb
--- /dev/null
+++ b/templates/sat.html
@@ -0,0 +1,28 @@
+<h1>Sat {{ self.sat.n() }}</h1>
+<dl>
+  <dt>decimal</dt><dd>{{ self.sat.decimal() }}</dd>
+  <dt>degree</dt><dd>{{ self.sat.degree() }}</dd>
+  <dt>percentile</dt><dd>{{ self.sat.percentile() }}</dd>
+  <dt>name</dt><dd>{{ self.sat.name() }}</dd>
+  <dt>cycle</dt><dd>{{ self.sat.cycle() }}</dd>
+  <dt>epoch</dt><dd>{{ self.sat.epoch() }}</dd>
+  <dt>period</dt><dd>{{ self.sat.period() }}</dd>
+  <dt>block</dt><dd>{{ self.sat.height() }}</dd>
+  <dt>offset</dt><dd>{{ self.sat.third() }}</dd>
+  <dt>rarity</dt><dd><span class={{self.sat.rarity()}}>{{ self.sat.rarity() }}</span></dd>
+  <dt>time</dt><dd>{{ self.blocktime }}</dd>
+%% if let Some(inscription) = &self.inscription {
+  <dt>inscription</dt>
+  <dd>{{ inscription.content_html() }}</dd>
+%% }
+</dl>
+%% if self.sat.n() > 0 {
+<a href=/sat/{{self.sat.n() - 1}}>prev</a>
+%% } else {
+prev
+%% }
+%% if self.sat < Sat::LAST {
+<a href=/sat/{{self.sat.n() + 1}}>next</a>
+%% } else {
+next
+%% }
diff --git a/test-bitcoincore-rpc/src/lib.rs b/test-bitcoincore-rpc/src/lib.rs
index 4c7322e637..478fd3ff19 100644
--- a/test-bitcoincore-rpc/src/lib.rs
+++ b/test-bitcoincore-rpc/src/lib.rs
@@ -50,7 +50,7 @@ pub fn spawn_with(network: Network, wallet_name: &str) -> Handle {
   thread::spawn(|| rpc_server.wait());
 
   for i in 0.. {
-    match reqwest::blocking::get(&format!("http://127.0.0.1:{port}/")) {
+    match reqwest::blocking::get(format!("http://127.0.0.1:{port}/")) {
       Ok(_) => break,
       Err(err) => {
         if i == 400 {
diff --git a/test-bitcoincore-rpc/src/server.rs b/test-bitcoincore-rpc/src/server.rs
index bb26bd32c7..ae85f77c8a 100644
--- a/test-bitcoincore-rpc/src/server.rs
+++ b/test-bitcoincore-rpc/src/server.rs
@@ -207,8 +207,8 @@ impl Api for Server {
         })
         .collect(),
       output: outs
-        .iter()
-        .map(|(_address, amount)| TxOut {
+        .values()
+        .map(|amount| TxOut {
           value: (*amount * COIN_VALUE as f64) as u64,
           script_pubkey: Script::new(),
         })
diff --git a/tests/find.rs b/tests/find.rs
index 9c6580b5af..aaa2551dc4 100644
--- a/tests/find.rs
+++ b/tests/find.rs
@@ -1,7 +1,7 @@
 use super::*;
 
 #[test]
-fn find_command_returns_satpoint_for_ordinal() {
+fn find_command_returns_satpoint_for_sat() {
   let rpc_server = test_bitcoincore_rpc::spawn();
   CommandBuilder::new("--index-satoshis find 0")
     .rpc_server(&rpc_server)
@@ -10,11 +10,11 @@ fn find_command_returns_satpoint_for_ordinal() {
 }
 
 #[test]
-fn unmined_ordinal() {
+fn unmined_sat() {
   let rpc_server = test_bitcoincore_rpc::spawn();
   CommandBuilder::new("--index-satoshis find 5000000000")
     .rpc_server(&rpc_server)
-    .expected_stderr("error: ordinal has not been mined as of index height\n")
+    .expected_stderr("error: sat has not been mined as of index height\n")
     .expected_exit_code(1)
     .run();
 }
diff --git a/tests/info.rs b/tests/info.rs
index ea6137ead4..ea6fb0d6e9 100644
--- a/tests/info.rs
+++ b/tests/info.rs
@@ -6,7 +6,7 @@ fn json_with_satoshi_index() {
   CommandBuilder::new("--index-satoshis info")
     .rpc_server(&rpc_server)
     .stdout_regex(
-      r#"\{"blocks_indexed":1,"branch_pages":\d+,"fragmented_bytes":\d+,"index_file_size":\d+,"leaf_pages":\d+,"metadata_bytes":\d+,"ordinal_ranges":1,"outputs_traversed":1,"page_size":\d+,"stored_bytes":\d+,"transactions":\[\{"starting_block_count":0,"starting_timestamp":\d+\}\],"tree_height":\d+,"utxos_indexed":1\}"#
+      r#"\{"blocks_indexed":1,"branch_pages":\d+,"fragmented_bytes":\d+,"index_file_size":\d+,"leaf_pages":\d+,"metadata_bytes":\d+,"sat_ranges":1,"outputs_traversed":1,"page_size":\d+,"stored_bytes":\d+,"transactions":\[\{"starting_block_count":0,"starting_timestamp":\d+\}\],"tree_height":\d+,"utxos_indexed":1\}"#
     )
     .run();
 }
@@ -17,7 +17,7 @@ fn json_without_satoshi_index() {
   CommandBuilder::new("info")
     .rpc_server(&rpc_server)
     .stdout_regex(
-      r#"\{"blocks_indexed":1,"branch_pages":\d+,"fragmented_bytes":\d+,"index_file_size":\d+,"leaf_pages":\d+,"metadata_bytes":\d+,"ordinal_ranges":0,"outputs_traversed":0,"page_size":\d+,"stored_bytes":\d+,"transactions":\[\{"starting_block_count":0,"starting_timestamp":\d+\}\],"tree_height":\d+,"utxos_indexed":0\}"#
+      r#"\{"blocks_indexed":1,"branch_pages":\d+,"fragmented_bytes":\d+,"index_file_size":\d+,"leaf_pages":\d+,"metadata_bytes":\d+,"sat_ranges":0,"outputs_traversed":0,"page_size":\d+,"stored_bytes":\d+,"transactions":\[\{"starting_block_count":0,"starting_timestamp":\d+\}\],"tree_height":\d+,"utxos_indexed":0\}"#
     )
     .run();
 }
diff --git a/tests/test_server.rs b/tests/test_server.rs
index cd2697dacb..c56f7cafdc 100644
--- a/tests/test_server.rs
+++ b/tests/test_server.rs
@@ -33,7 +33,7 @@ impl TestServer {
       .spawn().unwrap();
 
     for i in 0.. {
-      match reqwest::blocking::get(&format!("http://127.0.0.1:{port}/status")) {
+      match reqwest::blocking::get(format!("http://127.0.0.1:{port}/status")) {
         Ok(_) => break,
         Err(err) => {
           if i == 400 {
diff --git a/tests/traits.rs b/tests/traits.rs
index 39a9d7e993..a4a7f13f9b 100644
--- a/tests/traits.rs
+++ b/tests/traits.rs
@@ -1,7 +1,7 @@
 use super::*;
 
 #[test]
-fn traits_command_prints_ordinal_traits() {
+fn traits_command_prints_sat_traits() {
   CommandBuilder::new("traits 0")
     .expected_stdout(
       "\
diff --git a/tests/wallet.rs b/tests/wallet.rs
index d63456890c..15f226a723 100644
--- a/tests/wallet.rs
+++ b/tests/wallet.rs
@@ -38,7 +38,7 @@ fn satoshis_from_tsv_parse_error() {
     .rpc_server(&rpc_server)
     .expected_exit_code(1)
     .expected_stderr(
-      "error: failed to parse ordinal from string \"===\" on line 1: invalid digit found in string\n",
+      "error: failed to parse sat from string \"===\" on line 1: invalid digit found in string\n",
     )
     .run();
 }
@@ -248,7 +248,7 @@ fn inscribe() {
   rpc_server.mine_blocks(1);
 
   TestServer::spawn_with_args(&rpc_server, &["--index-satoshis"]).assert_response_regex(
-    "/ordinal/5000000000",
+    "/sat/5000000000",
     ".*<dt>inscription</dt>\n  <dd>HELLOWORLD</dd>.*",
   );
 
@@ -305,7 +305,7 @@ fn inscribe_png() {
   let ord_server = TestServer::spawn_with_args(&rpc_server, &["--index-satoshis"]);
 
   ord_server.assert_response_regex(
-    "/ordinal/5000000000",
+    "/sat/5000000000",
     ".*<dt>inscription</dt>\n  <dd><img src=.*",
   )
 }
@@ -601,7 +601,7 @@ fn inscribe_with_optional_satpoint_arg() {
   rpc_server.mine_blocks(1);
 
   TestServer::spawn_with_args(&rpc_server, &["--index-satoshis"]).assert_response_regex(
-    "/ordinal/5000000000",
+    "/sat/5000000000",
     ".*<dt>inscription</dt>\n  <dd>HELLOWORLD</dd>.*",
   );