rust doc fixes

Author: sanket1729

src/descriptor/csfs_cov/cov.rs

@@ -193,8 +193,7 @@ impl<Pk: MiniscriptKey, Ext: Extension> LegacyCSFSCov<Pk, Ext> {
 
     /// Script code for signing with covenant publickey.
     /// Use this script_code for sighash method when signing
-    /// with the covenant pk. Use the [DescriptorTrait] script_code
-    /// method for getting sighash for regular miniscripts.
+    /// with the covenant pk.
     pub fn cov_script_code(&self) -> Script
     where
         Pk: ToPublicKey,
@@ -279,8 +278,8 @@ impl<Ext: ParseableExt> LegacyCSFSCov<bitcoin::PublicKey, Ext> {
     }
 
     /// Parse a descriptor with additional local sanity checks.
-    /// See [Miniscript::sanity_check] for all the checks. Use
-    /// [parse_insane] to allow parsing insane scripts
+    /// See [`Miniscript::sanity_check`] for all the checks. Use
+    /// [`Miniscript::parse_insane`] to allow parsing insane scripts
     pub fn parse(script: &script::Script) -> Result<Self, Error> {
         let cov = Self::parse_insane(script)?;
         cov.ms.sanity_check()?;
@@ -430,7 +429,7 @@ where
 
     /// This returns the entire explicit script as the script code.
     /// You will need this script code when singing with pks that
-    /// inside Miniscript. Use the [cov_script_code] method to
+    /// inside Miniscript. Use the [`Self::cov_script_code`] method to
     /// get the script code for signing with covenant pk
     pub fn ecdsa_sighash_script_code(&self) -> Script
     where

src/descriptor/csfs_cov/script_internals.rs

@@ -27,7 +27,7 @@ pub trait CovOperations: Sized {
     /// len must be 33
     fn chk_amt(self) -> Self;
     /// Assuming the 10 sighash components + 1 sig on the top of
-    /// stack for segwit sighash as created by [init_stack]
+    /// stack for segwit sighash as created by init_stack
     /// CAT all of them and check sig from stack
     fn verify_cov(self, key: &bitcoin::PublicKey) -> Self;
 

src/descriptor/mod.rs

@@ -175,7 +175,8 @@ pub enum DescriptorInfo {
     },
     /// Pegin descriptor
     /// Only provides information about the bitcoin side of descriptor
-    /// Use [DescriptorTrait::user_desc] method to obtain the user descriptor
+    /// Use the corresponding [`pegin::LegacyPegin::into_user_descriptor`] or
+    /// [`pegin::Pegin::into_user_descriptor`] method to obtain the user descriptor.
     /// and call DescriptorType method on it on to find information about
     /// the user claim descriptor.
     Pegin {
@@ -187,12 +188,12 @@ pub enum DescriptorInfo {
 }
 
 impl DescriptorInfo {
-    /// Compute the [DescriptorInfo] for the given descriptor string
+    /// Compute the [`DescriptorInfo`] for the given descriptor string
     /// This method should when the user is unsure whether they are parsing
     /// Bitcoin Descriptor, Elements Descriptor or Pegin Descriptors.
     /// This also returns information whether the descriptor contains any secrets
-    /// of the type [DescriptorSecretKey]. If the descriptor contains secret, users
-    /// should use the method [DescriptorPublicKey::parse_descriptor] to obtain the
+    /// of the type [`DescriptorSecretKey`]. If the descriptor contains secret, users
+    /// should use the method [`Descriptor::parse_descriptor`] to obtain the
     /// Descriptor and a secret key to public key mapping
     pub fn from_desc_str<T: Extension>(s: &str) -> Result<Self, Error> {
         // Parse as a string descriptor

src/descriptor/pegin/mod.rs

@@ -24,4 +24,5 @@
 
 pub mod dynafed_pegin;
 pub mod legacy_pegin;
+pub use self::dynafed_pegin::Pegin;
 pub use self::legacy_pegin::{LegacyPegin, LegacyPeginKey};

src/extensions/arith.rs

@@ -34,63 +34,63 @@ use crate::{
 pub enum ExprInner {
     /* leaf fragments/terminals */
     /// A constant i64 value
-    /// Minimal push of this <i64>
+    /// Minimal push of this `<i64>`
     Const(i64),
     /// Value under the current executing input
-    /// INSPECTCURRENTINPUTINDEX INPSECTINPUTVALUE <1> EQUALVERIFY
+    /// `INSPECTCURRENTINPUTINDEX INPSECTINPUTVALUE <1> EQUALVERIFY`
     CurrInputIdx,
     /// Explicit amount at the given input index
-    /// i INPSECTINPUTVALUE <1> EQUALVERIFY
+    /// `i INPSECTINPUTVALUE <1> EQUALVERIFY`
     Input(IdxExpr),
     /// Explicit amount at the given output index
-    /// i INPSECTOUTPUTVALUE <1> EQUALVERIFY
+    /// `i INPSECTOUTPUTVALUE <1> EQUALVERIFY`
     Output(IdxExpr),
     /// Explicit issuance amount at this input index
-    /// i OP_INSPECTINPUTISSUANCE DROP DROP <1> EQUALVERIFY NIP NIP
+    /// `i OP_INSPECTINPUTISSUANCE DROP DROP <1> EQUALVERIFY NIP NIP`
     // NIP drops the second to top stack item
     // issuance stack after push where the right is stack top
     // [<inflation keys> <inflation_pref> <value> <value_pref> <entropy> <blindingnonce>]
     InputIssue(IdxExpr),
     /// Explicit re-issuance amount at this input index
-    /// i OP_INSPECTINPUTISSUANCE DROP DROP DROP DROP <1> EQUALVERIFY
+    /// `i OP_INSPECTINPUTISSUANCE DROP DROP DROP DROP <1> EQUALVERIFY`
     // issuance stack after push where the right is stack top
     // [<inflation keys> <inflation_pref> <value> <value_pref> <entropy> <blindingnonce>]
     InputReIssue(IdxExpr),
 
     /* Two children */
     /// Add two Arith expressions.
-    /// [X] [Y] ADD64 <1> EQUALVERIFY
+    /// `[X] [Y] ADD64 <1> EQUALVERIFY`
     Add(Box<Expr>, Box<Expr>),
     /// Subtract (X-Y)
-    /// [X] [Y] SUB64 <1> EQUALVERIFY
+    /// `[X] [Y] SUB64 <1> EQUALVERIFY`
     Sub(Box<Expr>, Box<Expr>),
     /// Multiply two Expr expressions. (a*b)
-    /// [X] [Y] MUL64 <1> EQUALVERIFY
+    /// `[X] [Y] MUL64 <1> EQUALVERIFY`
     Mul(Box<Expr>, Box<Expr>),
     /// Divide two Expr expressions. (a//b)
     /// The division operation pushes the quotient(a//b) such that the remainder a%b
     /// (must be non-negative and less than |b|).
-    /// [X] [Y] DIV64 <1> EQUALVERIFY NIP
+    /// `[X] [Y] DIV64 <1> EQUALVERIFY NIP`
     Div(Box<Expr>, Box<Expr>),
     /// Modulo operation (a % b)
     /// The division operation the remainder a%b (must be non-negative and less than |b|).
-    /// [X] [Y] DIV64 <1> EQUALVERIFY DROP
+    /// `[X] [Y] DIV64 <1> EQUALVERIFY DROP`
     Mod(Box<Expr>, Box<Expr>),
     /// BitWise And (a & b)
-    /// [X] [Y] AND (cannot fail)
+    /// `[X] [Y] AND` (cannot fail)
     BitAnd(Box<Expr>, Box<Expr>),
     /// BitWise or (a | b)
-    /// [X] [Y] OR (cannot fail)
+    /// `[X] [Y] OR` (cannot fail)
     BitOr(Box<Expr>, Box<Expr>),
     /// BitWise or (a ^ b)
-    /// [X] [Y] XOR (cannot fail)
+    /// `[X] [Y] XOR` (cannot fail)
     Xor(Box<Expr>, Box<Expr>),
     /* One child*/
     /// BitWise invert (!a)
-    /// [X] INVERT (cannot fail)
+    /// `[X] INVERT` (cannot fail)
     Invert(Box<Expr>),
     /// Negate -a
-    /// [X] NEG64 <1> EQUALVERIFY
+    /// `[X] NEG64 <1> EQUALVERIFY`
     Negate(Box<Expr>),
 }
 
@@ -528,19 +528,19 @@ impl Expr {
 #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Clone)]
 pub enum Arith {
     /// Eq
-    /// [X] [Y] EQUAL
+    /// `[X] [Y] EQUAL`
     Eq(Expr, Expr),
     /// Lt
-    /// [X] [Y] LESSTHAN
+    /// `[X] [Y] LESSTHAN`
     Lt(Expr, Expr),
     /// Leq
-    /// [X] [Y] LESSTHANOREQUAL
+    /// `[X] [Y] LESSTHANOREQUAL`
     Leq(Expr, Expr),
     /// Gt
-    /// [X] [Y] GREATERTHAN
+    /// `[X] [Y] GREATERTHAN`
     Gt(Expr, Expr),
     /// Geq
-    /// [X] [Y] GREATERTHANOREQUAL
+    /// `[X] [Y] GREATERTHANOREQUAL`
     Geq(Expr, Expr),
 }
 

src/extensions/index_ops.rs

@@ -17,26 +17,26 @@ use crate::{expression, script_num_size, Error};
 pub enum IdxExpr {
     /* leaf fragments/terminals */
     /// A constant
-    /// <i> as CScriptNum
+    /// `<i>` as CScriptNum
     Const(usize),
     /// Current Input index
     CurrIdx,
     /// Add two IdxExpr
-    /// [X] [Y] ADD`
+    /// `[X] [Y] ADD`
     Add(Box<IdxExpr>, Box<IdxExpr>),
     /// Subtract two IdxExpr
-    /// [X] [Y] SUB`
+    /// `[X] [Y] SUB`
     Sub(Box<IdxExpr>, Box<IdxExpr>),
     /// Multiply two IdxExpr
-    /// [X] SCIPTNUMTOLE64 [Y] SCIPTNUMTOLE64 MUL64 <1> EQUALVERIFY LE64TOSCIPTNUM`
+    /// `[X] SCIPTNUMTOLE64 [Y] SCIPTNUMTOLE64 MUL64 <1> EQUALVERIFY LE64TOSCIPTNUM`
     Mul(Box<IdxExpr>, Box<IdxExpr>),
     /// Divide two IdxExpr (integer division)
-    /// [X] SCIPTNUMTOLE64 [Y] SCIPTNUMTOLE64 DIV64 <1> EQUALVERIFY NIP LE64TOSCIPTNUM`
+    /// `[X] SCIPTNUMTOLE64 [Y] SCIPTNUMTOLE64 DIV64 <1> EQUALVERIFY NIP LE64TOSCIPTNUM`
     Div(Box<IdxExpr>, Box<IdxExpr>),
 }
 
 impl IdxExpr {
-    /// Returns the script size of this [`AssetExpr<T>`].
+    /// Returns the script size of this [`IdxExpr`].
     pub fn script_size(&self) -> usize {
         match self {
             IdxExpr::Const(i) => script_num_size(*i),
@@ -157,7 +157,7 @@ impl IdxExpr {
     }
 
     /// Returns (self, start_pos) parsed reversed form tokens starting with index end_pos
-    /// Expression is parsed from tokens[start:end_pos]
+    /// Expression is parsed from tokens `[start:end_pos]`
     #[rustfmt::skip]
     pub fn from_tokens(tokens: &[Tk], end_pos: usize) -> Option<(Self, usize)> {
         let tks = tokens;

src/extensions/introspect_ops.rs

@@ -34,16 +34,16 @@ use crate::{
 pub enum AssetExpr<T: ExtParam> {
     /* leaf fragments/terminals */
     /// A constant asset id
-    /// Minimal push of this <asset_id>
+    /// Minimal push of this `<asset_id>`
     Const(T),
     /// Asset under the current executing input
-    /// INSPECTCURRENTINPUTINDEX INPSECTINPUTASSET
+    /// `INSPECTCURRENTINPUTINDEX INPSECTINPUTASSET`
     CurrInputAsset,
     /// Explicit asset at the given input index
-    /// i INPSECTINPUTASSET
+    /// `i INPSECTINPUTASSET`
     Input(IdxExpr),
     /// Explicit asset at the given output index
-    /// i INPSECTOUTPUTASSET
+    /// `i INPSECTOUTPUTASSET`
     Output(IdxExpr),
 }
 
@@ -58,13 +58,13 @@ pub enum ValueExpr<T: ExtParam> {
     /// A constant Value
     Const(T),
     /// Value under the current executing input
-    /// INSPECTCURRENTINPUTINDEX INPSECTINPUTVALUE
+    /// `INSPECTCURRENTINPUTINDEX INPSECTINPUTVALUE`
     CurrInputValue,
     ///  Value(possibly confidential) at the given input index
-    /// i INPSECTINPUTVALUE
+    /// `i INPSECTINPUTVALUE`
     Input(IdxExpr),
     /// Value(possibly confidential) at the given output index
-    /// i INPSECTOUTPUTVALUE
+    /// `i INPSECTOUTPUTVALUE`
     Output(IdxExpr),
 }
 
@@ -82,13 +82,13 @@ pub enum SpkExpr<T: ExtParam> {
     /// Pushes -1 if the legacy script pubkeys followed by sha256 hash of script pubkey
     Const(T),
     /// Script pubkey under the current executing input
-    /// INSPECTCURRENTINPUTINDEX INPSECTINPUTSCRIPTPUBKEY
+    /// `INSPECTCURRENTINPUTINDEX INPSECTINPUTSCRIPTPUBKEY`
     CurrInputSpk,
     /// Explicit asset at the given input index
-    /// i INPSECTINPUTSCRIPTPUBKEY
+    /// `i INPSECTINPUTSCRIPTPUBKEY`
     Input(IdxExpr),
     /// Explicit asset at the given output index
-    /// i INPSECTOUTPUTSCRIPTPUBKEY
+    /// `i INPSECTOUTPUTSCRIPTPUBKEY`
     Output(IdxExpr),
 }
 
@@ -99,28 +99,28 @@ pub enum SpkExpr<T: ExtParam> {
 #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Clone)]
 pub enum CovOps<T: ExtParam> {
     /// Checks that asset is explicit
-    /// [X] <1> EQUAL NIP
+    /// `[X] <1> EQUAL NIP`
     IsExpAsset(AssetExpr<T>),
     /// Checks if the value is explicit
-    /// [X] <1> EQUAL NIP
+    /// `[X] <1> EQUAL NIP`
     /// The script translation is same as that of IsExpAsset, but the data structure
     /// distinguishes them for clarity.
     IsExpValue(ValueExpr<T>),
     /// Checks that both assets are equal (maybe confidential)
-    /// [X] TOALTSTACK [Y] FROMALTSTACK EQUAL TOALTSTACK EQUAL FROMALTSTACK BOOLAND
+    /// `[X] TOALTSTACK [Y] FROMALTSTACK EQUAL TOALTSTACK EQUAL FROMALTSTACK BOOLAND`
     AssetEq(AssetExpr<T>, AssetExpr<T>),
     /// Checks that both values are equal (maybe confidential)
-    /// [X] TOALTSTACK [Y] FROMALTSTACK EQUAL TOALTSTACK EQUAL FROMALTSTACK BOOLAND
+    /// `[X] TOALTSTACK [Y] FROMALTSTACK EQUAL TOALTSTACK EQUAL FROMALTSTACK BOOLAND`
     ValueEq(ValueExpr<T>, ValueExpr<T>),
     /// Script pubkey equal. Checks the witness version and program. Also works for
     /// legacy programs.
-    /// [X] TOALTSTACK [Y] FROMALTSTACK EQUAL TOALTSTACK EQUAL FROMALTSTACK BOOLAND
+    /// `[X] TOALTSTACK [Y] FROMALTSTACK EQUAL TOALTSTACK EQUAL FROMALTSTACK BOOLAND`
     SpkEq(SpkExpr<T>, SpkExpr<T>),
     /// Current input index equality
-    /// <i> PUSHCURRENTINPUTINDEX EQUAL
+    /// `<i> PUSHCURRENTINPUTINDEX EQUAL`
     CurrIndEq(usize),
     /// Index equality
-    /// [X] [Y] EQUAL
+    /// `[X] [Y] EQUAL`
     IdxEq(IdxExpr, IdxExpr),
 }
 
@@ -720,7 +720,7 @@ impl AssetExpr<CovExtArgs> {
     }
 
     /// Returns (self, start_pos) parsed reversed form tokens starting with index end_pos
-    /// Expression is parsed from tokens[start:end_pos]
+    /// Expression is parsed from tokens`[start:end_pos]`
     pub fn from_tokens(tokens: &[Tk], end_pos: usize) -> Option<(Self, usize)> {
         let tks = tokens;
         let e = end_pos; // short abbreviations for succinct readable code
@@ -808,7 +808,7 @@ impl ValueExpr<CovExtArgs> {
     }
 
     /// Returns (self, start_pos) parsed reversed form tokens starting with index end_pos
-    /// Expression is parsed from tokens[start:end_pos]
+    /// Expression is parsed from tokens`[start:end_pos]`
     pub fn from_tokens(tokens: &[Tk], end_pos: usize) -> Option<(Self, usize)> {
         let tks = tokens;
         let e = end_pos; // short abbreviations for succinct readable code
@@ -898,7 +898,7 @@ impl SpkExpr<CovExtArgs> {
     }
 
     /// Returns (self, start_pos) parsed reversed form tokens starting with index end_pos
-    /// Expression is parsed from tokens[start:end_pos]
+    /// Expression is parsed from tokens`[start:end_pos]`
     pub fn from_tokens(tokens: &[Tk], end_pos: usize) -> Option<(Self, usize)> {
         let tks = tokens;
         let e = end_pos; // short abbreviations for succinct readable code
@@ -1007,7 +1007,7 @@ impl CovOps<CovExtArgs> {
     }
 
     /// Returns (self, start_pos) parsed reversed form tokens starting with index end_pos
-    /// Expression is parsed from tokens[start:end_pos]
+    /// Expression is parsed from tokens`[start:end_pos]`
     pub fn from_tokens(tks: &[Tk]) -> Option<(Self, usize)> {
         let e = tks.len();
         if let Some(&[Tk::Num(i), Tk::CurrInp, Tk::Equal]) = tks.get(e.checked_sub(3)?..e) {

src/extensions/mod.rs

@@ -63,7 +63,7 @@ pub trait Extension: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
     }
 
     /// Create an instance of this object from a Tree with root name and children as
-    /// Vec<Tree>.
+    /// `Vec<Tree>`.
     // Ideally, we would want a FromTree implementation here, but that is not possible
     // as we would need to create a new Tree by removing wrappers from root.
     fn from_name_tree(_name: &str, children: &[Tree<'_>]) -> Result<Self, ()>;

src/extensions/outputs_pref.rs

@@ -30,9 +30,9 @@ use crate::{expression, interpreter, Error, Extension, MiniscriptKey, Satisfier,
 /// Even if the witness does not require 7 pushes, the user should push
 /// 7 elements with possibly empty values.
 ///
-/// CAT CAT CAT CAT CAT CAT <pref> SWAP CAT /*Now we hashoutputs on stack */
-/// HASH256
-/// DEPTH <10> SUB PICK EQUALVERIFY
+/// `CAT CAT CAT CAT CAT CAT <pref> SWAP CAT` /*Now we hashoutputs on stack */
+/// `HASH256`
+/// `DEPTH <10> SUB PICK EQUALVERIFY`
 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone)]
 pub struct LegacyOutputsPref {
     /// the version of transaction

src/extensions/param.rs

@@ -220,7 +220,7 @@ where
     type Output;
 
     /// Translates a struct from one generic to another where the translations
-    /// for Pk are provided by the given [`Translator`].
+    /// for Pk are provided by the given [`ExtParamTranslator`].
     fn translate_ext<T, E>(&self, translator: &mut T) -> Result<Self::Output, E>
     where
         T: ExtParamTranslator<PArg, QArg, E>;

src/miniscript/limits.rs

@@ -24,7 +24,7 @@ pub const MAX_SCRIPT_ELEMENT_SIZE: usize = 520;
 // https://github.com/bitcoin/bitcoin/blob/42b66a6b814bca130a9ccf0a3f747cf33d628232/src/policy/policy.cpp#L102
 pub const MAX_SCRIPTSIG_SIZE: usize = 1650;
 /// Maximum Initial witness size allowed
-/// https://github.com/bitcoin/bitcoin/blob/283a73d7eaea2907a6f7f800f529a0d6db53d7a6/src/policy/policy.h#L42
+/// `<https://github.com/bitcoin/bitcoin/blob/283a73d7eaea2907a6f7f800f529a0d6db53d7a6/src/policy/policy.h#L42>`
 pub const MAX_STANDARD_P2WSH_STACK_ITEM_SIZE: usize = 80;
 /// Maximum items during stack execution
 // This limits also applies for initial stack satisfaction