pset: sketch per-output value-only blinding

src/pset/error.rs

@@ -264,3 +264,57 @@ impl fmt::Display for PsetBlindError {
     }
 }
 impl error::Error for PsetBlindError {}
+
+#[allow(missing_docs)]
+#[derive(Clone, PartialEq, Eq, Debug)]
+#[non_exhaustive]
+pub enum BlindingModeError {
+    Blind(PsetBlindError),
+    UnusedMode(usize),
+    ZeroAmount(usize),
+    ZeroValueBlindingFactor(usize),
+    InputSecretsOutOfRange(usize),
+    InputSecretsMismatch(usize),
+    UnknownInputBlinding(usize),
+}
+
+impl fmt::Display for BlindingModeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            BlindingModeError::Blind(_) => f.write_str("PSET blinding failed"),
+            BlindingModeError::UnusedMode(i) => {
+                write!(f, "blinding mode given for output index {}, which is not blinded", i)
+            }
+            BlindingModeError::ZeroAmount(i) => {
+                write!(f, "amount at output index {} is zero", i)
+            }
+            BlindingModeError::ZeroValueBlindingFactor(i) => {
+                write!(f, "value blinding factor at output index {} would be zero", i)
+            }
+            BlindingModeError::InputSecretsOutOfRange(i) => {
+                write!(f, "secrets given for input index {}, which is out of range", i)
+            }
+            BlindingModeError::InputSecretsMismatch(i) => {
+                write!(f, "secrets for input index {} do not open its witness utxo", i)
+            }
+            BlindingModeError::UnknownInputBlinding(i) => write!(
+                f,
+                "input index {} is confidential with unknown blinding factors and no scalars",
+                i
+            ),
+        }
+    }
+}
+
+impl error::Error for BlindingModeError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            BlindingModeError::Blind(ref e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
+impl From<PsetBlindError> for BlindingModeError {
+    fn from(e: PsetBlindError) -> Self { BlindingModeError::Blind(e) }
+}

src/pset/map/output.rs

@@ -292,6 +292,18 @@ impl Output {
             && self.asset_surjection_proof.is_some()
             && self.ecdh_pubkey.is_some()
     }
+
+    #[allow(missing_docs)]
+    pub fn is_value_only_blinded(&self) -> bool {
+        self.is_marked_for_blinding()
+            && self.asset.is_some()
+            && self.asset_comm.is_none()
+            && self.asset_surjection_proof.is_none()
+            && self.blind_asset_proof.is_none()
+            && self.amount_comm.is_some()
+            && self.value_rangeproof.is_some()
+            && self.ecdh_pubkey.is_some()
+    }
 }
 
 impl Map for Output {
@@ -578,7 +590,11 @@ impl Decodable for Output {
         if let (Some(_), None) = (rv.blinding_key, rv.blinder_index) {
             return Err(encode::Error::PsetError(Error::MissingBlinderIndex));
         }
-        if rv.is_marked_for_blinding() && rv.is_partially_blinded() && !rv.is_fully_blinded() {
+        if rv.is_marked_for_blinding()
+            && rv.is_partially_blinded()
+            && !rv.is_fully_blinded()
+            && !rv.is_value_only_blinded()
+        {
             return Err(encode::Error::PsetError(Error::MissingBlindingInfo));
         }
         Ok(rv)