s/PrimitiveError/FfiValidationError/g

Rename error type and variants for clarity

Author: spacebear21

payjoin-ffi/dart/test/test_payjoin_integration_test.dart

@@ -374,7 +374,7 @@ Future<payjoin.ReceiveSession?> process_receiver_proposal(
 
 void main() {
   group('Test integration', () {
-    test('Invalid primitives', () async {
+    test('FFI validation', () async {
       final tooLargeAmount = 21000000 * 100000000 + 1;
       // Invalid outpoint should fail before amount checks.
       final txinInvalid = payjoin.PlainTxIn(
@@ -439,7 +439,7 @@ void main() {
 
       expect(
         () => pjUri.setAmountSats(tooLargeAmount),
-        throwsA(isA<payjoin.PrimitiveException>()),
+        throwsA(isA<payjoin.FfiValidationException>()),
       );
     });
 

payjoin-ffi/javascript/test/integration.test.ts

@@ -450,7 +450,7 @@ async function processReceiverProposal(
     throw new Error(`Unknown receiver state`);
 }
 
-function testInvalidPrimitives(): void {
+function testFfiValidation(): void {
     const tooLargeAmount = 21000000n * 100000000n + 1n;
 
     // Invalid outpoint (txid too long) should fail before amount checks.
@@ -486,9 +486,13 @@ function testInvalidPrimitives(): void {
         sequence: 0,
         witness: [],
     });
-    assert.throws(() => {
+    try {
         new payjoin.InputPair(amountOverflowTxIn, psbtIn, undefined);
-    }, /(Amount out of range|AmountOutOfRange)/);
+        assert.fail("Expected AmountOutOfRange error");
+    } catch (e) {
+        const [inner] = payjoin.InputPairError.FfiValidation.getInner(e);
+        assert.strictEqual(inner.tag, "AmountOutOfRange");
+    }
 
     // Oversized script_pubkey should fail.
     const hugeScript = new Uint8Array(10_001).fill(0x51).buffer;
@@ -501,9 +505,13 @@ function testInvalidPrimitives(): void {
         redeemScript: undefined,
         witnessScript: undefined,
     });
-    assert.throws(() => {
+    try {
         new payjoin.InputPair(amountOverflowTxIn, oversizedPsbtIn, undefined);
-    }, /(ScriptTooLarge|script too large|InvalidPrimitive)/);
+        assert.fail("Expected ScriptTooLarge error");
+    } catch (e) {
+        const [inner] = payjoin.InputPairError.FfiValidation.getInner(e);
+        assert.strictEqual(inner.tag, "ScriptTooLarge");
+    }
 
     // Weight must be positive and <= block weight.
     const smallTxOut = payjoin.PlainTxOut.create({
@@ -515,13 +523,17 @@ function testInvalidPrimitives(): void {
         redeemScript: undefined,
         witnessScript: undefined,
     });
-    assert.throws(() => {
+    try {
         new payjoin.InputPair(
             amountOverflowTxIn,
             smallPsbtIn,
             payjoin.PlainWeight.create({ weightUnits: 0n }),
         );
-    }, /(WeightOutOfRange|Weight out of range|InvalidPsbtInput|InvalidPrimitive)/);
+        assert.fail("Expected WeightOutOfRange error");
+    } catch (e) {
+        const [inner] = payjoin.InputPairError.FfiValidation.getInner(e);
+        assert.strictEqual(inner.tag, "WeightOutOfRange");
+    }
 
     const pjUri = payjoin.Uri.parse(
         "bitcoin:12c6DSiU4Rq3P4ZxziKxzrL5LmMBrzjrJX?amount=1&pj=https://example.com",
@@ -531,11 +543,11 @@ function testInvalidPrimitives(): void {
         new payjoin.SenderBuilder(psbt, pjUri).buildRecommended(
             18446744073709551615n,
         );
-    }, /(Fee rate out of range|RuntimeError)/);
+    }, /RuntimeError/);
 
     assert.throws(() => {
         pjUri.setAmountSats(tooLargeAmount);
-    }, /(Amount out of range|AmountOutOfRange)/);
+    }, /AmountOutOfRange/);
 }
 
 async function testIntegrationV2ToV2(): Promise<void> {
@@ -692,7 +704,7 @@ async function testIntegrationV2ToV2(): Promise<void> {
 
 async function runTests(): Promise<void> {
     await uniffiInitAsync();
-    testInvalidPrimitives();
+    testFfiValidation();
     await testIntegrationV2ToV2();
 }
 

payjoin-ffi/python/test/test_payjoin_integration_test.py

@@ -56,9 +56,10 @@ def setUpClass(cls):
         cls.receiver = cls.env.get_receiver()
         cls.sender = cls.env.get_sender()
 
-    async def test_invalid_primitives(self):
+    async def test_ffi_validation(self):
         too_large_amount = 21_000_000 * 100_000_000 + 1
-        # Invalid outpoint should fail before amount checks.
+
+        # Invalid outpoint (txid too long) should fail before amount checks.
         txin_invalid = PlainTxIn(
             previous_output=PlainOutPoint(txid="00" * 64, vout=0),
             script_sig=b"",
@@ -70,12 +71,11 @@ async def test_invalid_primitives(self):
             redeem_script=None,
             witness_script=None,
         )
-        with self.assertRaises(InputPairError):
+        with self.assertRaises(InputPairError.InvalidOutPoint):
             InputPair(txin=txin_invalid, psbtin=psbt_in_dummy, expected_weight=None)
 
-        # Valid outpoint hits amount overflow.
+        # Valid outpoint hits amount overflow validation.
         txin = PlainTxIn(
-            # valid 32-byte txid so we exercise amount overflow instead of outpoint parsing
             previous_output=PlainOutPoint(txid="00" * 32, vout=0),
             script_sig=b"",
             sequence=0,
@@ -89,15 +89,11 @@ async def test_invalid_primitives(self):
             redeem_script=None,
             witness_script=None,
         )
-        amount_oob_variant = getattr(InputPairError, "AmountOutOfRange", InputPairError)
-        with self.assertRaises(amount_oob_variant) as ctx:
+        with self.assertRaises(InputPairError.FfiValidation) as ctx:
             InputPair(txin=txin, psbtin=psbt_in, expected_weight=None)
-        # Cope with bindings that don't expose nested variants.
-        self.assertIsInstance(ctx.exception, InputPairError)
-        if amount_oob_variant is not InputPairError:
-            self.assertIsInstance(ctx.exception, amount_oob_variant)
+        self.assertIsInstance(ctx.exception[0], FfiValidationError.AmountOutOfRange)
 
-        # Use a real v2 payjoin URI from the receiver harness to avoid the v1 panic path.
+        # SenderBuilder rejects fee rate overflow.
         receiver_address = json.loads(self.receiver.call("getnewaddress", []))
         services = TestServices.initialize()
         services.wait_for_services_ready()
@@ -108,26 +104,13 @@ async def test_invalid_primitives(self):
             receiver_address, directory, ohttp_keys, recv_persister
         ).pj_uri()
 
-        sender_prim_variant = getattr(SenderInputError, "Primitive", SenderInputError)
-        with self.assertRaises(sender_prim_variant) as ctx:
+        with self.assertRaises(SenderInputError.FfiValidation) as ctx:
             SenderBuilder(original_psbt(), pj_uri).build_recommended(2**64 - 1)
-        if sender_prim_variant is not SenderInputError:
-            self.assertIsInstance(ctx.exception, sender_prim_variant)
-        fee_rate_variant = getattr(PrimitiveError, "FeeRateOutOfRange", PrimitiveError)
-        cause = ctx.exception.__cause__
-        if cause is not None:
-            self.assertIsInstance(cause, fee_rate_variant)
-        else:
-            self.assertIn("FeeRateOutOfRange", str(ctx.exception))
-
-        prim_amount_variant = getattr(
-            PrimitiveError, "AmountOutOfRange", PrimitiveError
-        )
-        with self.assertRaises(prim_amount_variant) as ctx:
+        self.assertIsInstance(ctx.exception[0], FfiValidationError.FeeRateOutOfRange)
+
+        # PjUri rejects amount out of range.
+        with self.assertRaises(FfiValidationError.AmountOutOfRange):
             pj_uri.set_amount_sats(too_large_amount)
-        self.assertIsInstance(ctx.exception, PrimitiveError)
-        if prim_amount_variant is not PrimitiveError:
-            self.assertIsInstance(ctx.exception, prim_amount_variant)
 
     async def process_receiver_proposal(
         self,

payjoin-ffi/src/error.rs

@@ -22,7 +22,7 @@ impl From<ImplementationError> for payjoin::ImplementationError {
 pub struct SerdeJsonError(#[from] serde_json::Error);
 
 #[derive(Debug, thiserror::Error, uniffi::Error)]
-pub enum PrimitiveError {
+pub enum FfiValidationError {
     #[error("Amount out of range: {amount_sat} sats (max {max_sat})")]
     AmountOutOfRange { amount_sat: u64, max_sat: u64 },
     #[error("{field} script is empty")]

payjoin-ffi/src/receive/error.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use payjoin::receive;
 
-use crate::error::{ImplementationError, PrimitiveError};
+use crate::error::{FfiValidationError, ImplementationError};
 use crate::uri::error::IntoUrlError;
 
 /// The top-level error type for the payjoin receiver
@@ -179,7 +179,7 @@ pub enum OutputSubstitutionError {
     #[error(transparent)]
     Protocol(Arc<OutputSubstitutionProtocolError>),
     #[error(transparent)]
-    Primitive(PrimitiveError),
+    FfiValidation(FfiValidationError),
 }
 
 impl From<receive::OutputSubstitutionError> for OutputSubstitutionError {
@@ -188,8 +188,8 @@ impl From<receive::OutputSubstitutionError> for OutputSubstitutionError {
     }
 }
 
-impl From<PrimitiveError> for OutputSubstitutionError {
-    fn from(value: PrimitiveError) -> Self { OutputSubstitutionError::Primitive(value) }
+impl From<FfiValidationError> for OutputSubstitutionError {
+    fn from(value: FfiValidationError) -> Self { OutputSubstitutionError::FfiValidation(value) }
 }
 
 /// Error that may occur when coin selection fails.
@@ -213,18 +213,12 @@ pub enum InputPairError {
     /// Provided outpoint could not be parsed.
     #[error("Invalid outpoint (txid={txid}, vout={vout})")]
     InvalidOutPoint { txid: String, vout: u32 },
-    /// Amount exceeds allowed maximum.
-    #[error("Amount out of range: {amount_sat} sats (max {max_sat})")]
-    AmountOutOfRange { amount_sat: u64, max_sat: u64 },
-    /// Weight must be positive and no more than a block.
-    #[error("Weight out of range: {weight_units} wu (max {max_wu})")]
-    WeightOutOfRange { weight_units: u64, max_wu: u64 },
     /// PSBT input failed validation in the core library.
     #[error("Invalid PSBT input: {0}")]
     InvalidPsbtInput(Arc<PsbtInputError>),
-    /// Primitive input failed validation in the FFI layer.
-    #[error("Invalid primitive input: {0}")]
-    InvalidPrimitive(PrimitiveError),
+    /// Input failed validation in the FFI layer.
+    #[error("Invalid input: {0}")]
+    FfiValidation(FfiValidationError),
 }
 
 impl InputPairError {
@@ -233,16 +227,8 @@ impl InputPairError {
     }
 }
 
-impl From<PrimitiveError> for InputPairError {
-    fn from(value: PrimitiveError) -> Self {
-        match value {
-            PrimitiveError::AmountOutOfRange { amount_sat, max_sat } =>
-                InputPairError::AmountOutOfRange { amount_sat, max_sat },
-            PrimitiveError::WeightOutOfRange { weight_units, max_wu } =>
-                InputPairError::WeightOutOfRange { weight_units, max_wu },
-            other => InputPairError::InvalidPrimitive(other),
-        }
-    }
+impl From<FfiValidationError> for InputPairError {
+    fn from(value: FfiValidationError) -> Self { InputPairError::FfiValidation(value) }
 }
 
 /// Error that may occur when a receiver event log is replayed

payjoin-ffi/src/receive/mod.rs

@@ -12,7 +12,7 @@ use payjoin::bitcoin::FeeRate;
 use payjoin::persist::{MaybeFatalTransition, NextStateTransition};
 
 use crate::error::ForeignError;
-pub use crate::error::{ImplementationError, PrimitiveError, SerdeJsonError};
+pub use crate::error::{FfiValidationError, ImplementationError, SerdeJsonError};
 use crate::ohttp::OhttpKeys;
 use crate::receive::error::{ReceiverPersistedError, ReceiverReplayError};
 use crate::uri::error::FeeRateError;
@@ -275,7 +275,7 @@ pub struct PlainTxOut {
 }
 
 impl PlainTxOut {
-    fn into_core(self) -> Result<payjoin::bitcoin::TxOut, PrimitiveError> {
+    fn into_core(self) -> Result<payjoin::bitcoin::TxOut, FfiValidationError> {
         let value = validate_amount_sat(self.value_sat)?;
         let script_pubkey = validate_script_vec("script_pubkey", self.script_pubkey, false)?;
         Ok(payjoin::bitcoin::TxOut { value, script_pubkey })
@@ -370,7 +370,7 @@ pub struct PlainWeight {
 }
 
 impl PlainWeight {
-    fn into_core(self) -> Result<payjoin::bitcoin::Weight, PrimitiveError> {
+    fn into_core(self) -> Result<payjoin::bitcoin::Weight, FfiValidationError> {
         validate_weight_units(self.weight_units)
     }
 }
@@ -409,12 +409,12 @@ impl ReceiverBuilder {
         ))
     }
 
-    pub fn with_amount(&self, amount_sats: u64) -> Result<Self, PrimitiveError> {
+    pub fn with_amount(&self, amount_sats: u64) -> Result<Self, FfiValidationError> {
         let amount = validate_amount_sat(amount_sats)?;
         Ok(Self(self.0.clone().with_amount(amount)))
     }
 
-    pub fn with_expiration(&self, expiration: u64) -> Result<Self, PrimitiveError> {
+    pub fn with_expiration(&self, expiration: u64) -> Result<Self, FfiValidationError> {
         let expiration = validate_expiration_secs(expiration)?;
         Ok(Self(self.0.clone().with_expiration(expiration)))
     }
@@ -638,7 +638,7 @@ impl UncheckedOriginalPayload {
         &self,
         min_fee_rate: Option<u64>,
         can_broadcast: Arc<dyn CanBroadcast>,
-    ) -> Result<UncheckedOriginalPayloadTransition, PrimitiveError> {
+    ) -> Result<UncheckedOriginalPayloadTransition, FfiValidationError> {
         let min_fee_rate = validate_fee_rate_sat_per_kwu_opt(min_fee_rate)?;
         Ok(UncheckedOriginalPayloadTransition(Arc::new(RwLock::new(Some(
             self.0.clone().check_broadcast_suitability(min_fee_rate, |transaction| {
@@ -1031,7 +1031,7 @@ impl WantsFeeRange {
         &self,
         min_fee_rate_sat_per_vb: Option<u64>,
         max_effective_fee_rate_sat_per_vb: Option<u64>,
-    ) -> Result<WantsFeeRangeTransition, PrimitiveError> {
+    ) -> Result<WantsFeeRangeTransition, FfiValidationError> {
         let min_fee_rate_sat_per_vb = validate_fee_rate_sat_per_vb_opt(min_fee_rate_sat_per_vb)?;
         let max_effective_fee_rate_sat_per_vb =
             validate_fee_rate_sat_per_vb_opt(max_effective_fee_rate_sat_per_vb)?;

payjoin-ffi/src/send/error.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use payjoin::bitcoin::psbt::PsbtParseError as CorePsbtParseError;
 use payjoin::send;
 
-use crate::error::{ImplementationError, PrimitiveError};
+use crate::error::{FfiValidationError, ImplementationError};
 
 /// Error building a Sender from a SenderBuilder.
 ///
@@ -42,11 +42,11 @@ pub enum SenderInputError {
     #[error(transparent)]
     Build(Arc<BuildSenderError>),
     #[error(transparent)]
-    Primitive(PrimitiveError),
+    FfiValidation(FfiValidationError),
 }
 
-impl From<PrimitiveError> for SenderInputError {
-    fn from(value: PrimitiveError) -> Self { SenderInputError::Primitive(value) }
+impl From<FfiValidationError> for SenderInputError {
+    fn from(value: FfiValidationError) -> Self { SenderInputError::FfiValidation(value) }
 }
 
 /// Error returned when request could not be created.

payjoin-ffi/src/uri/mod.rs

@@ -5,7 +5,7 @@ pub use error::{PjNotSupported, PjParseError, UrlParseError};
 use payjoin::bitcoin::address::NetworkChecked;
 use payjoin::UriExt;
 
-use crate::error::PrimitiveError;
+use crate::error::FfiValidationError;
 use crate::validation::validate_amount_sat;
 
 pub mod error;
@@ -65,7 +65,7 @@ impl PjUri {
     pub fn amount_sats(&self) -> Option<u64> { self.0.clone().amount.map(|e| e.to_sat()) }
 
     /// Sets the amount in sats and returns a new PjUri
-    pub fn set_amount_sats(&self, amount_sats: u64) -> Result<Self, PrimitiveError> {
+    pub fn set_amount_sats(&self, amount_sats: u64) -> Result<Self, FfiValidationError> {
         let mut uri = self.0.clone();
         let amount = validate_amount_sat(amount_sats)?;
         uri.amount = Some(amount);