tweak invoice rpc for payment hash and preimage

Author: chenyukang

crates/fiber-lib/src/fiber/tests/mpp.rs

@@ -2997,7 +2997,7 @@ async fn test_send_mpp_with_generated_invoice() {
     let too_large_amount_invoice = nodes[1]
         .gen_invoice(NewInvoiceParams {
             amount: 20000000001,
-            payment_preimage: gen_rand_sha256_hash(),
+            payment_preimage: Some(gen_rand_sha256_hash()),
             allow_mpp: Some(true),
             ..Default::default()
         })
@@ -3017,7 +3017,7 @@ async fn test_send_mpp_with_generated_invoice() {
     let ok_invoice = nodes[1]
         .gen_invoice(NewInvoiceParams {
             amount: 20000000000,
-            payment_preimage: gen_rand_sha256_hash(),
+            payment_preimage: Some(gen_rand_sha256_hash()),
             allow_mpp: Some(true),
             ..Default::default()
         })

crates/fiber-lib/src/fiber/tests/rpc.rs

@@ -29,9 +29,8 @@ fn rpc_config_with_auth() -> (RpcConfig, KeyPair) {
     (config, root)
 }
 
-#[tokio::test]
-async fn test_rpc_basic() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
+async fn gen_mock_network() -> (Vec<NetworkNode>, Vec<Hash256>) {
+    create_n_nodes_network_with_params(
         &[
             (
                 (0, 1),
@@ -55,7 +54,13 @@ async fn test_rpc_basic() {
         2,
         Some(gen_rpc_config()),
     )
-    .await;
+    .await
+}
+
+#[tokio::test]
+async fn test_rpc_basic() {
+    let (nodes, _channels) = gen_mock_network().await;
+
     let [node_0, node_1] = nodes.try_into().expect("2 nodes");
 
     let res: ListChannelsResult = node_0
@@ -93,7 +98,8 @@ async fn test_rpc_basic() {
         fallback_address: None,
         final_expiry_delta: Some(900000 + 1234),
         udt_type_script: Some(Script::default().into()),
-        payment_preimage: Hash256::default(),
+        payment_preimage: Some(Hash256::default()),
+        payment_hash: None,
         hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
         allow_mpp: Some(true),
         atomic_mpp: None,
@@ -145,7 +151,8 @@ async fn test_rpc_basic() {
         fallback_address: None,
         final_expiry_delta: Some(900000 + 1234),
         udt_type_script: Some(Script::default().into()),
-        payment_preimage: gen_rand_sha256_hash(),
+        payment_preimage: Some(gen_rand_sha256_hash()),
+        payment_hash: None,
         hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
         allow_mpp: Some(false),
         atomic_mpp: None,
@@ -161,6 +168,40 @@ async fn test_rpc_basic() {
     assert!(internal_ckb_invoice.payment_secret().is_none());
 }
 
+#[tokio::test]
+async fn test_invoice_rpc() {
+    let (nodes, _channels) = gen_mock_network().await;
+
+    let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
+
+    let payment_hash = gen_rand_sha256_hash();
+    let new_invoice_params = NewInvoiceParams {
+        amount: 1000,
+        description: Some("test".to_string()),
+        currency: Currency::Fibd,
+        expiry: Some(322),
+        fallback_address: None,
+        final_expiry_delta: Some(900000 + 1234),
+        udt_type_script: Some(Script::default().into()),
+        payment_preimage: None,
+        payment_hash: Some(payment_hash),
+        hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
+        allow_mpp: None,
+        atomic_mpp: Some(true),
+    };
+
+    // node0 generate a invoice
+    let invoice_res: InvoiceResult = node_0
+        .send_rpc_request("new_invoice", new_invoice_params)
+        .await
+        .unwrap();
+
+    let ckb_invoice = invoice_res.invoice.clone();
+    let invoice_payment_hash = ckb_invoice.data.payment_hash;
+    assert_eq!(invoice_payment_hash, payment_hash);
+    assert!(node_0.get_payment_preimage(&payment_hash).is_none());
+}
+
 #[tokio::test]
 async fn test_rpc_list_peers() {
     let (nodes, _channels) = create_n_nodes_network_with_params(
@@ -239,31 +280,7 @@ async fn test_rpc_list_peers() {
 
 #[tokio::test]
 async fn test_rpc_graph() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
-        &[
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-        ],
-        2,
-        Some(gen_rpc_config()),
-    )
-    .await;
+    let (nodes, _channels) = gen_mock_network().await;
     let [node_0, node_1] = nodes.try_into().expect("2 nodes");
 
     let graph_nodes: GraphNodesResult = node_0
@@ -290,31 +307,8 @@ async fn test_rpc_graph() {
 
 #[tokio::test]
 async fn test_rpc_shutdown_channels() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
-        &[
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-        ],
-        2,
-        Some(gen_rpc_config()),
-    )
-    .await;
+    let (nodes, _channels) = gen_mock_network().await;
+
     let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
 
     let list_channels: ListChannelsResult = node_0
@@ -413,31 +407,8 @@ async fn test_rpc_shutdown_channels() {
 
 #[tokio::test]
 async fn test_rpc_node_info() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
-        &[
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-        ],
-        2,
-        Some(gen_rpc_config()),
-    )
-    .await;
+    let (nodes, _channels) = gen_mock_network().await;
+
     let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
 
     let node_info: NodeInfoResult = node_0.send_rpc_request("node_info", ()).await.unwrap();
@@ -537,7 +508,8 @@ async fn test_rpc_basic_with_auth() {
                 fallback_address: None,
                 final_expiry_delta: Some(900000 + 1234),
                 udt_type_script: Some(Script::default().into()),
-                payment_preimage: Hash256::default(),
+                payment_preimage: Some(Hash256::default()),
+                payment_hash: None,
                 hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
                 allow_mpp: None,
                 atomic_mpp: None,

crates/fiber-lib/src/fiber/tests/types.rs

@@ -517,13 +517,13 @@ fn test_verify_hard_coded_node_announcement() {
 
     for (signature, message, node_announcement) in [
         (
-            "80a0e9d4ed35eb76e086038983dfd2572e7298a795b4cde7b113d805eeb495192cf552e4cc631e73fee76c4f0479a33327488f8a99978a10e2583b7faba2cf61",
-            "044e5172e9a9d7b383c15f40d8dac30f86422e7082af2b4d7db7f5484b4a1701",
+            "cfe5d1dde285bac326fb290899c14bd05b9afa013c61c3c9338daca07ab0d287647c2101482bc193913b91da0e9284ebd352f1139149b8943876c78ff46608fc",
+            "e387e01002f45594d36577ac53c822f8712b378ed52e8dde3bfbdb3b01b29abc",
             node1(),
         ),
         (
-            "3a1eea2e372e5c3bc53d1c283d449afbfff029308fe59e111a23ad32163d2a6f58128e21083e128a05d34fb8c0068a1f4fa6e4ae12e370d3051591df151a957a",
-            "db96ac7278d1db7b03eefdc4d21c952e3aee8a4be87a82c8c0e66a87e8897a81",
+            "1fec23d92c9fc9fafd39f477bf1fbb79cfb8f63604a6aeb0712cfd7dbe31e4e21a174f4e6733e78970f4489859aa1ba615fe712d4d212dd7f1c1a6678dff5d00",
+            "3e612fcfa66885352ac18e1fdd602199fb125fa4435ea509f472c0c870b0d307",
             node2(),
         ),
     ] {

crates/fiber-lib/src/invoice/errors.rs

@@ -47,6 +47,9 @@ pub enum InvoiceError {
     DuplicatedAttributeKey(String),
     #[error("Payment secret is required for MPP payments")]
     PaymentSecretRequiredForMpp,
+    /// Neither payment_hash nor payment_preimage is set
+    #[error("Neither payment_hash nor payment_preimage is set")]
+    NeitherPaymenthashNorPreimage,
     /// Both set payment_hash and payment_preimage
     #[error("Both payment_hash and payment_preimage are set")]
     BothPaymenthashAndPreimage,

crates/fiber-lib/src/invoice/invoice_impl.rs

@@ -5,7 +5,6 @@ use crate::fiber::gen::invoice::{self as gen_invoice, *};
 use crate::fiber::hash_algorithm::HashAlgorithm;
 use crate::fiber::serde_utils::{duration_hex, EntityHex, U128Hex, U64Hex};
 use crate::fiber::types::Hash256;
-use crate::gen_rand_sha256_hash;
 use crate::invoice::InvoiceError;
 use bech32::{encode, u5, FromBase32, ToBase32, Variant, WriteBase32};
 use bitcoin::hashes::{sha256::Hash as Sha256, Hash as _};
@@ -709,27 +708,22 @@ impl InvoiceBuilder {
     }
 
     pub fn build(self) -> Result<CkbInvoice, InvoiceError> {
-        let preimage = self.payment_preimage;
-
-        if self.payment_hash.is_some() && preimage.is_some() {
-            return Err(InvoiceError::BothPaymenthashAndPreimage);
-        }
-        let payment_hash: Hash256 = if let Some(preimage) = preimage {
-            let algo = self
-                .attrs
-                .iter()
-                .find_map(|attr| match attr {
-                    Attribute::HashAlgorithm(algo) => Some(algo),
-                    _ => None,
-                })
-                .copied()
-                .unwrap_or_default();
-            algo.hash(preimage.as_ref()).into()
-        } else if let Some(payment_hash) = self.payment_hash {
-            payment_hash
-        } else {
-            // generate a random payment hash if not provided
-            gen_rand_sha256_hash()
+        let payment_hash: Hash256 = match (self.payment_hash, self.payment_preimage) {
+            (Some(payment_hash), None) => payment_hash,
+            (None, Some(preimage)) => {
+                let algo = self
+                    .attrs
+                    .iter()
+                    .find_map(|attr| match attr {
+                        Attribute::HashAlgorithm(algo) => Some(algo),
+                        _ => None,
+                    })
+                    .copied()
+                    .unwrap_or_default();
+                algo.hash(preimage.as_ref()).into()
+            }
+            (Some(_), Some(_)) => return Err(InvoiceError::BothPaymenthashAndPreimage),
+            (None, None) => return Err(InvoiceError::NeitherPaymenthashNorPreimage),
         };
 
         self.check_attrs_valid()?;

crates/fiber-lib/src/invoice/tests/invoice_impl.rs

@@ -492,7 +492,11 @@ fn test_invoice_rand_payment_hash() {
     let invoice = InvoiceBuilder::new(Currency::Fibb)
         .amount(Some(1280))
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key));
-    assert!(invoice.is_ok());
+    eprintln!("invoice: {:?}", invoice);
+    assert_eq!(
+        invoice.err(),
+        Some(InvoiceError::NeitherPaymenthashNorPreimage)
+    );
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]

crates/fiber-lib/src/rpc/README.md

@@ -521,14 +521,16 @@ Generates a new invoice.
 * `amount` - <em>`u128`</em>, The amount of the invoice.
 * `description` - <em>`Option<String>`</em>, The description of the invoice.
 * `currency` - <em>[Currency](#type-currency)</em>, The currency of the invoice.
-* `payment_preimage` - <em>[Hash256](#type-hash256)</em>, The payment preimage of the invoice.
+* `payment_preimage` - <em>Option<[Hash256](#type-hash256)></em>, The preimage to settle an incoming TLC payable to this invoice. If preimage is set, hash must be absent. If both preimage and hash are absent, a random preimage is generated.
+* `payment_hash` - <em>Option<[Hash256](#type-hash256)></em>, The hash of the preimage. If hash is set, preimage must be absent. This condition indicates a 'hold invoice' for which the tlc must be accepted and held until the preimage becomes known.
 * `expiry` - <em>`Option<u64>`</em>, The expiry time of the invoice, in seconds.
 * `fallback_address` - <em>`Option<String>`</em>, The fallback address of the invoice.
 * `final_expiry_delta` - <em>`Option<u64>`</em>, The final HTLC timeout of the invoice, in milliseconds.
  Minimal value is 16 hours, and maximal value is 14 days.
 * `udt_type_script` - <em>`Option<Script>`</em>, The UDT type script of the invoice.
 * `hash_algorithm` - <em>Option<[HashAlgorithm](#type-hashalgorithm)></em>, The hash algorithm of the invoice.
 * `allow_mpp` - <em>`Option<bool>`</em>, Whether allow payment to use MPP
+* `atomic_mpp` - <em>`Option<bool>`</em>, Whether use atomic mpp, if use atomic mpp there will be no preimage generated.
 
 ##### Returns
 

crates/fiber-lib/src/rpc/invoice.rs

@@ -12,7 +12,7 @@ use crate::invoice::{
     Currency, InvoiceBuilder, InvoiceData as InternalInvoiceData, InvoiceSignature, InvoiceStore,
 };
 
-use crate::FiberConfig;
+use crate::{gen_rand_sha256_hash, FiberConfig};
 use ckb_jsonrpc_types::Script;
 use jsonrpsee::types::{error::CALL_EXECUTION_FAILED_CODE, ErrorObjectOwned};
 
@@ -141,8 +141,10 @@ pub struct NewInvoiceParams {
     pub description: Option<String>,
     /// The currency of the invoice.
     pub currency: Currency,
-    /// The payment preimage of the invoice.
-    pub payment_preimage: Hash256,
+    /// The preimage to settle an incoming TLC payable to this invoice. If preimage is set, hash must be absent. If both preimage and hash are absent, a random preimage is generated.
+    pub payment_preimage: Option<Hash256>,
+    /// The hash of the preimage. If hash is set, preimage must be absent. This condition indicates a 'hold invoice' for which the tlc must be accepted and held until the preimage becomes known.
+    pub payment_hash: Option<Hash256>,
     /// The expiry time of the invoice, in seconds.
     #[serde_as(as = "Option<U64Hex>")]
     pub expiry: Option<u64>,
@@ -325,9 +327,23 @@ where
                 ));
             }
         }
-        let mut invoice_builder = InvoiceBuilder::new(params.currency)
-            .amount(Some(params.amount))
-            .payment_preimage(params.payment_preimage);
+
+        let mut invoice_builder = InvoiceBuilder::new(params.currency).amount(Some(params.amount));
+
+        // If both preimage and payment hash are absent, a random preimage is generated.
+        let need_gen_preimage =
+            params.payment_hash.is_none() && params.atomic_mpp.is_none_or(|atomic| !atomic);
+        let preimage_opt = params
+            .payment_preimage
+            .or_else(|| need_gen_preimage.then(gen_rand_sha256_hash));
+
+        if let Some(preimage) = preimage_opt {
+            invoice_builder = invoice_builder.payment_preimage(preimage);
+        }
+        if let Some(hash) = params.payment_hash {
+            invoice_builder = invoice_builder.payment_hash(hash);
+        }
+
         if let Some(description) = params.description.clone() {
             invoice_builder = invoice_builder.description(description);
         };
@@ -391,10 +407,7 @@ where
         };
 
         match invoice {
-            Ok(invoice) => match self
-                .store
-                .insert_invoice(invoice.clone(), Some(params.payment_preimage))
-            {
+            Ok(invoice) => match self.store.insert_invoice(invoice.clone(), preimage_opt) {
                 Ok(_) => Ok(InvoiceResult {
                     invoice_address: invoice.to_string(),
                     invoice: invoice.into(),

crates/fiber-lib/src/tests/test_utils.rs

@@ -908,6 +908,7 @@ impl NetworkNode {
         params: P,
     ) -> Result<R, String> {
         let response = self.send_rpc_request_raw(method, params).await?;
+        eprintln!("response: {:?}", response);
         let result = serde_json::from_value::<R>(response.clone())
             .map_err(|e| format!("failed to deserialize response: {}", e))?;
         Ok(result)