diff --git a/src/accountant.rs b/src/accountant.rs
index b1cb6b232..c84cb7012 100644
--- a/src/accountant.rs
+++ b/src/accountant.rs
@@ -7,7 +7,7 @@ use entry::Entry;
 use event::Event;
 use transaction::Transaction;
 use signature::{KeyPair, PublicKey, Signature};
-use genesis::Genesis;
+use mint::Mint;
 use historian::{reserve_signature, Historian};
 use std::sync::mpsc::SendError;
 use std::collections::HashMap;
@@ -62,8 +62,8 @@ impl Accountant {
         acc
     }
 
-    pub fn new(gen: &Genesis, ms_per_tick: Option<u64>) -> Self {
-        Self::new_from_entries(gen.create_entries(), ms_per_tick)
+    pub fn new(mint: &Mint, ms_per_tick: Option<u64>) -> Self {
+        Self::new_from_entries(mint.create_entries(), ms_per_tick)
     }
 
     pub fn sync(self: &mut Self) -> Hash {
@@ -151,7 +151,7 @@ mod tests {
 
     #[test]
     fn test_accountant() {
-        let alice = Genesis::new(10_000);
+        let alice = Mint::new(10_000);
         let bob_pubkey = KeyPair::new().pubkey();
         let mut acc = Accountant::new(&alice, Some(2));
         acc.transfer(1_000, &alice.keypair(), bob_pubkey).unwrap();
@@ -169,7 +169,7 @@ mod tests {
 
     #[test]
     fn test_invalid_transfer() {
-        let alice = Genesis::new(11_000);
+        let alice = Mint::new(11_000);
         let mut acc = Accountant::new(&alice, Some(2));
         let bob_pubkey = KeyPair::new().pubkey();
         acc.transfer(1_000, &alice.keypair(), bob_pubkey).unwrap();
@@ -191,7 +191,7 @@ mod tests {
 
     #[test]
     fn test_transfer_to_newb() {
-        let alice = Genesis::new(10_000);
+        let alice = Mint::new(10_000);
         let mut acc = Accountant::new(&alice, Some(2));
         let alice_keypair = alice.keypair();
         let bob_pubkey = KeyPair::new().pubkey();
diff --git a/src/accountant_stub.rs b/src/accountant_stub.rs
index b55ddb46c..bc842474f 100644
--- a/src/accountant_stub.rs
+++ b/src/accountant_stub.rs
@@ -115,14 +115,14 @@ mod tests {
     use accountant_skel::AccountantSkel;
     use std::thread::{sleep, spawn};
     use std::time::Duration;
-    use genesis::Genesis;
+    use mint::Mint;
     use signature::{KeyPair, KeyPairUtil};
 
     #[test]
     fn test_accountant_stub() {
         let addr = "127.0.0.1:9000";
         let send_addr = "127.0.0.1:9001";
-        let alice = Genesis::new(10_000);
+        let alice = Mint::new(10_000);
         let acc = Accountant::new(&alice, None);
         let bob_pubkey = KeyPair::new().pubkey();
         spawn(move || AccountantSkel::new(acc).serve(addr).unwrap());
diff --git a/src/bin/client-demo.rs b/src/bin/client-demo.rs
index ff1f142e9..7a3f4b4fd 100644
--- a/src/bin/client-demo.rs
+++ b/src/bin/client-demo.rs
@@ -4,7 +4,7 @@ extern crate silk;
 use silk::accountant_stub::AccountantStub;
 use silk::signature::{KeyPair, KeyPairUtil};
 use silk::transaction::Transaction;
-use silk::genesis::Genesis;
+use silk::mint::Mint;
 use std::time::Instant;
 use std::net::UdpSocket;
 use std::io::stdin;
@@ -13,23 +13,23 @@ fn main() {
     let addr = "127.0.0.1:8000";
     let send_addr = "127.0.0.1:8001";
 
-    let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
-    let alice_keypair = gen.keypair();
-    let alice_pubkey = gen.pubkey();
+    let mint: Mint = serde_json::from_reader(stdin()).unwrap();
+    let mint_keypair = mint.keypair();
+    let mint_pubkey = mint.pubkey();
 
     let socket = UdpSocket::bind(send_addr).unwrap();
     let mut acc = AccountantStub::new(addr, socket);
     let last_id = acc.get_last_id().unwrap();
 
-    let txs = acc.get_balance(&alice_pubkey).unwrap().unwrap();
-    println!("Alice's Initial Balance {}", txs);
+    let txs = acc.get_balance(&mint_pubkey).unwrap().unwrap();
+    println!("Mint's Initial Balance {}", txs);
 
     println!("Signing transactions...");
     let now = Instant::now();
     let transactions: Vec<_> = (0..txs)
         .map(|_| {
             let rando_pubkey = KeyPair::new().pubkey();
-            Transaction::new(&alice_keypair, rando_pubkey, 1, last_id)
+            Transaction::new(&mint_keypair, rando_pubkey, 1, last_id)
         })
         .collect();
     let duration = now.elapsed();
@@ -71,7 +71,7 @@ fn main() {
     let ns = duration.as_secs() * 1_000_000_000 + duration.subsec_nanos() as u64;
     let tps = (txs * 1_000_000_000) as f64 / ns as f64;
     println!("Done. {} tps!", tps);
-    let val = acc.get_balance(&alice_pubkey).unwrap().unwrap();
-    println!("Alice's Final Balance {}", val);
+    let val = acc.get_balance(&mint_pubkey).unwrap().unwrap();
+    println!("Mint's Final Balance {}", val);
     assert_eq!(val, 0);
 }
diff --git a/src/bin/genesis-demo.rs b/src/bin/genesis-demo.rs
index 170c46b8b..ad3772d53 100644
--- a/src/bin/genesis-demo.rs
+++ b/src/bin/genesis-demo.rs
@@ -1,7 +1,7 @@
 extern crate serde_json;
 extern crate silk;
 
-use silk::genesis::Genesis;
+use silk::mint::Mint;
 use silk::event::Event;
 use silk::transaction::Transaction;
 use silk::log::create_entries;
@@ -17,10 +17,10 @@ fn main() {
     let alice = (KeyPair::new().pubkey(), 200);
     let bob = (KeyPair::new().pubkey(), 100);
 
-    let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
-    let from = gen.keypair();
-    let seed = gen.seed();
-    let mut events = gen.create_events();
+    let mint: Mint = serde_json::from_reader(stdin()).unwrap();
+    let from = mint.keypair();
+    let seed = mint.seed();
+    let mut events = mint.create_events();
     events.push(transfer(&from, alice, seed));
     events.push(transfer(&from, bob, seed));
 
diff --git a/src/bin/genesis.rs b/src/bin/genesis.rs
index d239767d9..8a241cb40 100644
--- a/src/bin/genesis.rs
+++ b/src/bin/genesis.rs
@@ -3,12 +3,12 @@
 extern crate serde_json;
 extern crate silk;
 
-use silk::genesis::Genesis;
+use silk::mint::Mint;
 use std::io::stdin;
 
 fn main() {
-    let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
-    for x in gen.create_entries() {
+    let mint: Mint = serde_json::from_reader(stdin()).unwrap();
+    for x in mint.create_entries() {
         println!("{}", serde_json::to_string(&x).unwrap());
     }
 }
diff --git a/src/bin/mint.rs b/src/bin/mint.rs
index 2c4300605..e1527dbc9 100644
--- a/src/bin/mint.rs
+++ b/src/bin/mint.rs
@@ -1,15 +1,15 @@
 extern crate serde_json;
 extern crate silk;
 
-use silk::genesis::Genesis;
+use silk::mint::Mint;
 use std::io;
 
 fn main() {
     let mut input_text = String::new();
     io::stdin().read_line(&mut input_text).unwrap();
-
     let trimmed = input_text.trim();
     let tokens = trimmed.parse::<i64>().unwrap();
-    let gen = Genesis::new(tokens);
-    println!("{}", serde_json::to_string(&gen).unwrap());
+
+    let mint = Mint::new(tokens);
+    println!("{}", serde_json::to_string(&mint).unwrap());
 }
diff --git a/src/lib.rs b/src/lib.rs
index e452859c9..01cbc93ae 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,7 @@ pub mod transaction;
 pub mod event;
 pub mod entry;
 pub mod log;
-pub mod genesis;
+pub mod mint;
 pub mod logger;
 pub mod historian;
 pub mod accountant;
diff --git a/src/genesis.rs b/src/mint.rs
similarity index 88%
rename from src/genesis.rs
rename to src/mint.rs
index 8e1f1e981..f35773777 100644
--- a/src/genesis.rs
+++ b/src/mint.rs
@@ -10,16 +10,16 @@ use ring::rand::SystemRandom;
 use untrusted::Input;
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct Genesis {
+pub struct Mint {
     pub pkcs8: Vec<u8>,
     pub tokens: i64,
 }
 
-impl Genesis {
+impl Mint {
     pub fn new(tokens: i64) -> Self {
         let rnd = SystemRandom::new();
         let pkcs8 = KeyPair::generate_pkcs8(&rnd).unwrap().to_vec();
-        Genesis { pkcs8, tokens }
+        Mint { pkcs8, tokens }
     }
 
     pub fn seed(&self) -> Hash {
@@ -51,7 +51,7 @@ mod tests {
 
     #[test]
     fn test_create_events() {
-        let mut events = Genesis::new(100).create_events().into_iter();
+        let mut events = Mint::new(100).create_events().into_iter();
         assert_eq!(events.next().unwrap(), Event::Tick);
         if let Event::Transaction(tr) = events.next().unwrap() {
             assert_eq!(tr.from, tr.to);
@@ -63,7 +63,7 @@ mod tests {
 
     #[test]
     fn test_verify_entries() {
-        let entries = Genesis::new(100).create_entries();
+        let entries = Mint::new(100).create_entries();
         assert!(verify_slice(&entries, &entries[0].id));
     }
 }