Merge rust-bitcoin/rust-bitcoin#6954: units: serialize unsigned amounts as u64

### units/src/amount/serde.rs
@@ -80,10 +80,14 @@ pub mod as_sat {
     #[inline]
     pub fn serialize<A, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error>
     where
-        A: Into<SignedAmount> + Copy,
+        A: Into<SignedAmount> + TryFrom<SignedAmount> + Copy,
     {
-        let amount: SignedAmount = (*a).into();
-        i64::serialize(&amount.to_sat(), s)
+        let sat = (*a).into().to_sat();
+        if is_signed::<A>() {
+            i64::serialize(&sat, s)
+        } else {
+            u64::serialize(&(sat as u64), s)
+        }
     }
 
     #[inline]
@@ -168,9 +172,14 @@ pub mod as_sat {
         #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<A, S: Serializer>(a: &Option<A>, s: S) -> Result<S::Ok, S::Error>
         where
-            A: Into<SignedAmount> + Copy,
+            A: Into<SignedAmount> + TryFrom<SignedAmount> + Copy,
         {
-            a.map(Into::into).map(SignedAmount::to_sat).serialize(s)
+            let sat = a.map(Into::into).map(SignedAmount::to_sat);
+            if is_signed::<A>() {
+                sat.serialize(s)
+            } else {
+                sat.map(|sat| sat as u64).serialize(s)
+            }
         }
 
         pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<Option<A>, D::Error>
@@ -242,9 +251,14 @@ pub mod as_sat {
         #[inline]
         pub fn serialize<A, S: Serializer>(a: &[A], s: S) -> Result<S::Ok, S::Error>
         where
-            A: Into<SignedAmount> + Copy,
+            A: Into<SignedAmount> + TryFrom<SignedAmount> + Copy,
         {
-            s.collect_seq(a.iter().map(|&amount| amount.into()).map(SignedAmount::to_sat))
+            let sats = a.iter().map(|&amount| amount.into()).map(SignedAmount::to_sat);
+            if is_signed::<A>() {
+                s.collect_seq(sats)
+            } else {
+                s.collect_seq(sats.map(|sat| sat as u64))
+            }
         }
 
         pub fn deserialize<'d, A, D: Deserializer<'d>>(d: D) -> Result<Vec<A>, D::Error>

### units/tests/serde.rs
@@ -115,6 +115,28 @@ fn sat(sat: u64) -> Amount { Amount::from_sat(sat).unwrap() }
 #[track_caller]
 fn ssat(ssat: i64) -> SignedAmount { SignedAmount::from_sat(ssat).unwrap() }
 
+#[test]
+fn serde_amount_as_sat_varint_round_trip() {
+    // Other tests use JSON and serde_test, which carry the type with
+    // the value and ignore the deserialize hint.
+    // Varint bincode bytes do not say if a number is signed, so the
+    // deserialize hint decides how they get decoded.
+    use bincode::Options as _;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::amount::serde::as_sat")]
+        pub amt: Amount,
+    }
+
+    let opts = || bincode::DefaultOptions::new().with_varint_encoding();
+    for amt in [Amount::ZERO, Amount::ONE_SAT, Amount::MAX] {
+        let t = T { amt };
+        let bytes = opts().serialize(&t).unwrap();
+        assert_eq!(opts().deserialize::<T>(&bytes).unwrap(), t);
+    }
+}
+
 #[test]
 #[cfg(feature = "serde")]
 fn serde_amount_as_sat() {
@@ -131,14 +153,33 @@ fn serde_amount_as_sat() {
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::Str("amt"),
-            serde_test::Token::I64(123_456_789),
+            serde_test::Token::U64(123_456_789),
             serde_test::Token::Str("samt"),
             serde_test::Token::I64(-123_456_789),
             serde_test::Token::StructEnd,
         ],
     );
 }
 
+#[test]
+fn serde_amount_as_sat_accepts_positive_i64() {
+    #[derive(Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::amount::serde::as_sat")]
+        pub amt: Amount,
+    }
+
+    serde_test::assert_de_tokens(
+        &T { amt: sat(123_456_789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 1 },
+            serde_test::Token::Str("amt"),
+            serde_test::Token::I64(123_456_789),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 #[cfg(feature = "serde")]
 #[cfg(feature = "alloc")]
@@ -160,9 +201,9 @@ fn serde_amount_as_sat_vec() {
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::Str("amt"),
             serde_test::Token::Seq { len: Some(3) },
-            serde_test::Token::I64(123),
-            serde_test::Token::I64(456),
-            serde_test::Token::I64(789),
+            serde_test::Token::U64(123),
+            serde_test::Token::U64(456),
+            serde_test::Token::U64(789),
             serde_test::Token::SeqEnd,
             serde_test::Token::Str("samt"),
             serde_test::Token::Seq { len: Some(3) },