Decimal::to_amount → Decimal::to_integer (ordinals#3382)

src/decimal.rs

@@ -7,7 +7,7 @@ pub struct Decimal {
 }
 
 impl Decimal {
- pub fn to_amount(self, divisibility: u8) -> Result<u128> {
+ pub fn to_integer(self, divisibility: u8) -> Result<u128> {
  match divisibility.checked_sub(self.scale) {
  Some(difference) => Ok(
  self
@@ -128,15 +128,15 @@ mod tests {
  assert_eq!(
  s.parse::<Decimal>()
  .unwrap()
- .to_amount(divisibility)
+ .to_integer(divisibility)
  .unwrap(),
  amount,
  );
  }
 
  assert_eq!(
  Decimal { value: 0, scale: 0 }
- .to_amount(255)
+ .to_integer(255)
  .unwrap_err()
  .to_string(),
  "divisibility out of range"
@@ -147,15 +147,15 @@ mod tests {
  value: u128::MAX,
  scale: 0,
  }
- .to_amount(1)
+ .to_integer(1)
  .unwrap_err()
  .to_string(),
  "amount out of range",
  );
 
  assert_eq!(
  Decimal { value: 1, scale: 1 }
- .to_amount(0)
+ .to_integer(0)
  .unwrap_err()
  .to_string(),
  "excessive precision",

src/subcommand/wallet/inscribe.rs

@@ -235,16 +235,16 @@ impl Inscribe {
  "rune `{rune}` has already been etched",
  );
 
- let premine = etching.premine.to_amount(etching.divisibility)?;
+ let premine = etching.premine.to_integer(etching.divisibility)?;
 
- let supply = etching.supply.to_amount(etching.divisibility)?;
+ let supply = etching.supply.to_integer(etching.divisibility)?;
 
  let mintable = etching
  .terms
  .map(|terms| -> Result<u128> {
  terms
  .cap
- .checked_mul(terms.amount.to_amount(etching.divisibility)?)
+ .checked_mul(terms.amount.to_integer(etching.divisibility)?)
  .ok_or_else(|| anyhow!("`terms.count` * `terms.amount` over maximum"))
  })
  .transpose()?
@@ -295,10 +295,10 @@ impl Inscribe {
  );
  }
 
- ensure!(terms.cap > 0, "`terms.cap` must be greater than zero",);
+ ensure!(terms.cap > 0, "`terms.cap` must be greater than zero");
 
  ensure!(
- terms.amount.to_amount(etching.divisibility)? > 0,
+ terms.amount.to_integer(etching.divisibility)? > 0,
  "`terms.amount` must be greater than zero",
  );
  }

src/subcommand/wallet/send.rs

@@ -231,7 +231,7 @@ impl Send {
  .get_rune(spaced_rune.rune)?
  .with_context(|| format!("rune `{}` has not been etched", spaced_rune.rune))?;
 
- let amount = decimal.to_amount(entry.divisibility)?;
+ let amount = decimal.to_integer(entry.divisibility)?;
 
  let inscribed_outputs = inscriptions
  .keys()

src/wallet/batch/plan.rs

@@ -433,7 +433,7 @@ impl Plan {
 
  let vout;
  let destination;
- premine = etching.premine.to_amount(etching.divisibility)?;
+ premine = etching.premine.to_integer(etching.divisibility)?;
 
  if premine > 0 {
  let output = u32::try_from(reveal_outputs.len()).unwrap();
@@ -470,7 +470,7 @@ impl Plan {
  terms.height.and_then(|range| (range.start)),
  terms.height.and_then(|range| (range.end)),
  ),
- amount: Some(terms.amount.to_amount(etching.divisibility)?),
+ amount: Some(terms.amount.to_integer(etching.divisibility)?),
  offset: (
  terms.offset.and_then(|range| (range.start)),
  terms.offset.and_then(|range| (range.end)),

tests/lib.rs

@@ -257,11 +257,11 @@ fn batch(
  } = batchfile.etching.unwrap();
 
  {
- let supply = supply.to_amount(divisibility).unwrap();
- let premine = premine.to_amount(divisibility).unwrap();
+ let supply = supply.to_integer(divisibility).unwrap();
+ let premine = premine.to_integer(divisibility).unwrap();
 
  let mintable = terms
- .map(|terms| terms.cap * terms.amount.to_amount(divisibility).unwrap())
+ .map(|terms| terms.cap * terms.amount.to_integer(divisibility).unwrap())
  .unwrap_or_default();
 
  assert_eq!(supply, premine + mintable);
@@ -324,7 +324,7 @@ fn batch(
  mint_definition.push(format!(
  "<dd>{}</dd>",
  Pile {
- amount: terms.amount.to_amount(divisibility).unwrap(),
+ amount: terms.amount.to_integer(divisibility).unwrap(),
  divisibility,
  symbol: Some(symbol),
  }
@@ -384,7 +384,7 @@ fn batch(
  rune,
  } = inscribe.rune.clone().unwrap();
 
- if premine.to_amount(divisibility).unwrap() > 0 {
+ if premine.to_integer(divisibility).unwrap() > 0 {
  let destination = destination
  .unwrap()
  .clone()