Mint runes with wallet

crates/test-bitcoincore-rpc/src/api.rs

@@ -12,6 +12,9 @@ pub trait Api {
   #[rpc(name = "getbalances")]
   fn get_balances(&self) -> Result<GetBalancesResult, jsonrpc_core::Error>;
 
+  #[rpc(name = "getbestblockhash")]
+  fn get_best_block_hash(&self) -> Result<bitcoin::BlockHash, jsonrpc_core::Error>;
+
   #[rpc(name = "getblockhash")]
   fn get_block_hash(&self, height: usize) -> Result<BlockHash, jsonrpc_core::Error>;
 

crates/test-bitcoincore-rpc/src/server.rs

@@ -46,6 +46,13 @@ impl Api for Server {
     })
   }
 
+  fn get_best_block_hash(&self) -> Result<bitcoin::BlockHash, jsonrpc_core::Error> {
+    match self.state().hashes.last() {
+      Some(block_hash) => Ok(*block_hash),
+      None => Err(Self::not_found()),
+    }
+  }
+
   fn get_blockchain_info(&self) -> Result<GetBlockchainInfoResult, jsonrpc_core::Error> {
     Ok(GetBlockchainInfoResult {
       chain: String::from(match self.network {
@@ -373,7 +380,9 @@ impl Api for Server {
       let (additional_input_value, outpoint) = utxos
         .iter()
         .find(|(value, outpoint)| value.to_sat() >= shortfall && !state.locked.contains(outpoint))
-        .ok_or_else(Self::not_found)?;
+        .ok_or_else(|| {
+          jsonrpc_core::Error::new(jsonrpc_core::types::error::ErrorCode::ServerError(-6))
+        })?;
 
       transaction.input.push(TxIn {
         previous_output: *outpoint,

src/index.rs

@@ -11,6 +11,7 @@ use {
   },
   super::*,
   crate::{
+    runes::MintError,
     subcommand::{find::FindRangeOutput, server::query},
     templates::StatusHtml,
   },

src/index/entry.rs

@@ -43,6 +43,28 @@ pub struct RuneEntry {
   pub timestamp: u32,
 }
 
+impl RuneEntry {
+  pub fn mintable(&self, block_height: Height, block_time: u32) -> Result<u128, MintError> {
+    let Some(mint) = self.mint else {
+      return Err(MintError::Unmintable(self.rune));
+    };
+
+    if let Some(end) = mint.end {
+      if block_height.0 >= end {
+        return Err(MintError::End((self.rune, end)));
+      }
+    }
+
+    if let Some(deadline) = mint.deadline {
+      if block_time >= deadline {
+        return Err(MintError::Deadline((self.rune, deadline)));
+      }
+    }
+
+    Ok(mint.limit.unwrap_or(runes::MAX_LIMIT))
+  }
+}
+
 pub(super) type RuneEntryValue = (
   u128,                   // burned
   u8,                     // divisibility
@@ -59,9 +81,9 @@ pub(super) type RuneEntryValue = (
 
 #[derive(Debug, PartialEq, Copy, Clone, Serialize, Deserialize, Default)]
 pub struct MintEntry {
-  pub deadline: Option<u32>,
-  pub end: Option<u32>,
-  pub limit: Option<u128>,
+  pub deadline: Option<u32>, // unix timestamp
+  pub end: Option<u32>,      // block height
+  pub limit: Option<u128>,   // claim amount
 }
 
 type MintEntryValue = (

src/index/updater.rs

@@ -600,7 +600,7 @@ impl<'index> Updater<'index> {
         runes,
         sequence_number_to_rune_id: &mut sequence_number_to_rune_id,
         statistic_to_count: &mut statistic_to_count,
-        timestamp: block.header.time,
+        block_time: block.header.time,
         transaction_id_to_rune: &mut transaction_id_to_rune,
         updates: HashMap::new(),
       };

src/index/updater/rune_updater.rs

@@ -4,7 +4,7 @@ use {
 };
 
 struct Claim {
-  id: u128,
+  id: RuneId,
   limit: u128,
 }
 
@@ -35,7 +35,7 @@ pub(super) struct RuneUpdater<'a, 'db, 'tx> {
   pub(super) runes: u64,
   pub(super) sequence_number_to_rune_id: &'a mut Table<'db, 'tx, u32, RuneIdValue>,
   pub(super) statistic_to_count: &'a mut Table<'db, 'tx, u64, u64>,
-  pub(super) timestamp: u32,
+  pub(super) block_time: u32,
   pub(super) transaction_id_to_rune: &'a mut Table<'db, 'tx, &'static TxidValue, u128>,
   pub(super) updates: HashMap<RuneId, RuneUpdate>,
 }
@@ -65,12 +65,9 @@ impl<'a, 'db, 'tx> RuneUpdater<'a, 'db, 'tx> {
         .and_then(|id| self.claim(id).transpose())
         .transpose()?
       {
-        *unallocated.entry(claim.id).or_default() += claim.limit;
+        *unallocated.entry(claim.id.into()).or_default() += claim.limit;
 
-        let update = self
-          .updates
-          .entry(RuneId::try_from(claim.id).unwrap())
-          .or_default();
+        let update = self.updates.entry(claim.id).or_default();
 
         update.mints += 1;
         update.supply += claim.limit;
@@ -283,7 +280,7 @@ impl<'a, 'db, 'tx> RuneUpdater<'a, 'db, 'tx> {
           u128::MAX
         } - balance,
         symbol,
-        timestamp: self.timestamp,
+        timestamp: self.block_time,
       }
       .store(),
     )?;
@@ -367,37 +364,18 @@ impl<'a, 'db, 'tx> RuneUpdater<'a, 'db, 'tx> {
     }))
   }
 
-  fn claim(&self, id: u128) -> Result<Option<Claim>> {
-    let Ok(key) = RuneId::try_from(id) else {
-      return Ok(None);
-    };
-
-    let Some(entry) = self.id_to_entry.get(&key.store())? else {
+  fn claim(&self, id: RuneId) -> Result<Option<Claim>> {
+    let Some(entry) = self.id_to_entry.get(&id.store())? else {
       return Ok(None);
     };
 
-    let entry = RuneEntry::load(entry.value());
+    let rune_entry = RuneEntry::load(entry.value());
 
-    let Some(mint) = entry.mint else {
+    let Ok(limit) = rune_entry.mintable(Height(self.height), self.block_time) else {
       return Ok(None);
     };
 
-    if let Some(end) = mint.end {
-      if self.height >= end {
-        return Ok(None);
-      }
-    }
-
-    if let Some(deadline) = mint.deadline {
-      if self.timestamp >= deadline {
-        return Ok(None);
-      }
-    }
-
-    Ok(Some(Claim {
-      id,
-      limit: mint.limit.unwrap_or(runes::MAX_LIMIT),
-    }))
+    Ok(Some(Claim { id, limit }))
   }
 
   fn unallocated(&mut self, tx: &Transaction) -> Result<HashMap<u128, u128>> {

src/lib.rs

@@ -162,7 +162,19 @@ fn fund_raw_transaction(
           ..Default::default()
         }),
         Some(false),
-      )?
+      )
+      .map_err(|err| {
+        if matches!(
+          err,
+          bitcoincore_rpc::Error::JsonRpc(bitcoincore_rpc::jsonrpc::Error::Rpc(
+            bitcoincore_rpc::jsonrpc::error::RpcError { code: -6, .. }
+          ))
+        ) {
+          anyhow!("not enough cardinal utxos")
+        } else {
+          err.into()
+        }
+      })?
       .hex,
   )
 }

src/runes.rs

@@ -5,10 +5,10 @@ use {
 
 pub use {edict::Edict, rune::Rune, rune_id::RuneId, runestone::Runestone};
 
-pub(crate) use {etching::Etching, mint::Mint, pile::Pile, spaced_rune::SpacedRune};
+pub use {etching::Etching, mint::Mint, pile::Pile, spaced_rune::SpacedRune};
 
 pub const MAX_DIVISIBILITY: u8 = 38;
-pub(crate) const MAX_LIMIT: u128 = 1 << 64;
+pub const MAX_LIMIT: u128 = 1 << 64;
 const RESERVED: u128 = 6402364363415443603228541259936211926;
 
 mod edict;
@@ -25,6 +25,25 @@ pub mod varint;
 
 type Result<T, E = Error> = std::result::Result<T, E>;
 
+#[derive(Debug)]
+pub enum MintError {
+  Deadline((Rune, u32)),
+  End((Rune, u32)),
+  Unmintable(Rune),
+}
+
+impl fmt::Display for MintError {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+      MintError::Deadline((rune, deadline)) => {
+        write!(f, "rune {rune} mint ended at {deadline}")
+      }
+      MintError::End((rune, end)) => write!(f, "rune {rune} mint ended on block {end}"),
+      MintError::Unmintable(rune) => write!(f, "rune {rune} not mintable"),
+    }
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use {super::*, crate::index::testing::Context};
@@ -4273,7 +4292,7 @@ mod tests {
       inputs: &[(2, 0, 0, Witness::new())],
       op_return: Some(
         Runestone {
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4370,7 +4389,7 @@ mod tests {
             amount: 1000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4415,7 +4434,7 @@ mod tests {
             amount: 1000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4465,7 +4484,7 @@ mod tests {
       op_return: Some(
         Runestone {
           burn: true,
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           edicts: vec![Edict {
             id: u128::from(id),
             amount: 1000,
@@ -4576,7 +4595,7 @@ mod tests {
             amount: 1000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4621,7 +4640,7 @@ mod tests {
             amount: 1000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4724,7 +4743,7 @@ mod tests {
             amount: 1,
             output: 3,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4813,7 +4832,7 @@ mod tests {
             amount: 1000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4858,7 +4877,7 @@ mod tests {
             amount: 1000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -4954,7 +4973,7 @@ mod tests {
             amount: 0,
             output: 3,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -5114,7 +5133,7 @@ mod tests {
             amount: MAX_LIMIT + 1,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -5266,7 +5285,7 @@ mod tests {
             amount: 2000,
             output: 0,
           }],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),
@@ -5386,7 +5405,7 @@ mod tests {
               output: 0,
             },
           ],
-          claim: Some(u128::from(id)),
+          claim: Some(id),
           ..Default::default()
         }
         .encipher(),

src/runes/mint.rs

@@ -2,7 +2,7 @@ use super::*;
 
 #[derive(Default, Serialize, Debug, PartialEq, Copy, Clone)]
 pub struct Mint {
-  pub deadline: Option<u32>,
-  pub limit: Option<u128>,
-  pub term: Option<u32>,
+  pub deadline: Option<u32>, // unix timestamp
+  pub limit: Option<u128>,   // claim amount
+  pub term: Option<u32>,     // relative block height
 }