fixup! Update ldk-node dependency

AI assistance: OpenAI Codex was used for this change.

Author: benthecarman

docs/api-guide.md

@@ -113,8 +113,8 @@ These RPCs support a manual claim/fail workflow for held payments. See
 | RPC                    | Description                                                        |
 |------------------------|--------------------------------------------------------------------|
 | `Bolt11ReceiveForHash` | Create an invoice for a given payment hash (manual claim required) |
-| `Bolt11ClaimForHash`   | Claim a held payment by providing the preimage                     |
-| `Bolt11FailForHash`    | Reject a held payment                                              |
+| `Bolt11ClaimForId`      | Claim a held payment by its payment ID and preimage                |
+| `Bolt11FailForId`       | Reject a held payment by its payment ID                            |
 
 ### BOLT11 JIT Channels (LSPS2)
 
@@ -231,11 +231,11 @@ optional Basic Auth. See [Configuration](configuration.md#metrics) for setup.
 Hodl invoices allow you to inspect and conditionally accept incoming payments:
 
 1. **Create the invoice:** Call `Bolt11ReceiveForHash` with a payment hash you control.
-2. **Wait for payment:** Subscribe to events via `SubscribeEvents` and watch for a
-   `PaymentClaimable` event matching your payment hash.
+2. **Wait for payment:** Subscribe via `SubscribeEvents`. Save the payment ID from the matching
+   `PaymentClaimable` event.
 3. **Decide:**
-    - **Accept:** Call `Bolt11ClaimForHash` with the preimage corresponding to the payment hash.
-    - **Reject:** Call `Bolt11FailForHash` with the payment hash.
+    - **Accept:** Call `Bolt11ClaimForId` with the payment ID and corresponding preimage.
+    - **Reject:** Call `Bolt11FailForId` with the payment ID.
 
 The payment is held in a pending state until you explicitly claim or fail it. **You must
 always call one of these.** If you do neither, the HTLC will eventually time out, which

e2e-tests/tests/e2e.rs

@@ -1418,15 +1418,11 @@ async fn test_hodl_invoice_claim() {
 
 	setup_funded_channel(&bitcoind, &server_a, &server_b, 100_000).await;
 
-	// Test three claim variants: (preimage, amount, hash)
-	let test_cases: Vec<([u8; 32], Option<&str>, bool)> = vec![
-		([42u8; 32], Some("10000000msat"), true),  // all args
-		([44u8; 32], Some("10000000msat"), false), // preimage + amount
-		([45u8; 32], None, true),                  // preimage + hash
-		([46u8; 32], None, false),                 // preimage only
-	];
-
-	for (preimage_bytes, amount, include_hash) in &test_cases {
+	// Test claiming with and without amount verification.
+	let test_cases: Vec<([u8; 32], Option<&str>)> =
+		vec![([42u8; 32], Some("10000000msat")), ([46u8; 32], None)];
+
+	for (preimage_bytes, amount) in &test_cases {
 		let preimage_hex = preimage_bytes.to_lower_hex_string();
 		let payment_hash_hex =
 			sha256::Hash::hash(preimage_bytes).to_byte_array().to_lower_hex_string();
@@ -1452,24 +1448,18 @@ async fn test_hodl_invoice_claim() {
 		// Wait for PaymentClaimable event on B (drain other events)
 		let claimable =
 			wait_for_event(&mut events_b, |e| matches!(e, Event::PaymentClaimable(_))).await;
-		assert!(matches!(
-			&claimable.event,
-			Some(Event::PaymentClaimable(event))
-				if event.claim_deadline.is_some()
-					&& event
-						.payment
-						.as_ref()
-						.is_some_and(|p| !p.payment_id.is_empty())
-		));
+		let Some(Event::PaymentClaimable(claimable_event)) = &claimable.event else {
+			panic!("expected PaymentClaimable");
+		};
+		assert!(claimable_event.claim_deadline.is_some());
+		assert!(!claimable_event.payment_id.is_empty());
 
 		// Claim the payment on B
-		let mut args: Vec<&str> = vec!["bolt11-claim-for-hash", &preimage_hex];
+		let mut args: Vec<&str> =
+			vec!["bolt11-claim-for-id", &claimable_event.payment_id, &preimage_hex];
 		if let Some(amt) = amount {
 			args.extend(["-c", amt]);
 		}
-		if *include_hash {
-			args.extend(["-p", &payment_hash_hex]);
-		}
 		run_cli(&server_b, &args);
 
 		// Wait for PaymentSuccessful on A after claim (drain other events)
@@ -1521,10 +1511,10 @@ async fn test_hodl_invoice_fail() {
 	let Some(Event::PaymentClaimable(claimable)) = &event_b.event else {
 		panic!("expected PaymentClaimable");
 	};
-	assert!(!claimable.payment.as_ref().unwrap().payment_id.is_empty());
+	assert!(!claimable.payment_id.is_empty());
 
 	// Fail the payment on B using CLI
-	run_cli(&server_b, &["bolt11-fail-for-hash", &payment_hash_hex]);
+	run_cli(&server_b, &["bolt11-fail-for-id", &claimable.payment_id]);
 
 	// Verify PaymentFailed on A
 	let event_a = wait_for_event(&mut events_a, |e| matches!(e, Event::PaymentFailed(_))).await;

ldk-server-cli/src/main.rs

@@ -23,8 +23,8 @@ use ldk_server_client::error::LdkServerErrorCode::{
 	AuthError, InternalError, InternalServerError, InvalidRequestError, LightningError,
 };
 use ldk_server_client::ldk_server_grpc::api::{
-	Bolt11ClaimForHashRequest, Bolt11ClaimForHashResponse, Bolt11FailForHashRequest,
-	Bolt11FailForHashResponse, Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse,
+	Bolt11ClaimForIdRequest, Bolt11ClaimForIdResponse, Bolt11FailForIdRequest,
+	Bolt11FailForIdResponse, Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse,
 	Bolt11ReceiveRequest, Bolt11ReceiveResponse, Bolt11ReceiveVariableAmountViaJitChannelRequest,
 	Bolt11ReceiveVariableAmountViaJitChannelResponse, Bolt11ReceiveViaJitChannelRequest,
 	Bolt11ReceiveViaJitChannelResponse, Bolt11SendRequest, Bolt11SendResponse,
@@ -167,7 +167,9 @@ enum Commands {
 		expiry_secs: Option<u32>,
 	},
 	#[command(about = "Claim a held payment by providing the preimage")]
-	Bolt11ClaimForHash {
+	Bolt11ClaimForId {
+		#[arg(help = "The hex-encoded 32-byte payment ID from PaymentClaimable")]
+		payment_id: String,
 		#[arg(help = "The hex-encoded 32-byte payment preimage")]
 		preimage: String,
 		#[arg(
@@ -176,17 +178,11 @@ enum Commands {
 			help = "The claimable amount, e.g. 50sat or 50000msat, only used for verifying we are claiming the expected amount"
 		)]
 		claimable_amount: Option<Amount>,
-		#[arg(
-			short,
-			long,
-			help = "The hex-encoded 32-byte payment hash, used to verify the preimage matches"
-		)]
-		payment_hash: Option<String>,
 	},
 	#[command(about = "Fail/reject a held payment")]
-	Bolt11FailForHash {
-		#[arg(help = "The hex-encoded 32-byte payment hash")]
-		payment_hash: String,
+	Bolt11FailForId {
+		#[arg(help = "The hex-encoded 32-byte payment ID from PaymentClaimable")]
+		payment_id: String,
 	},
 	#[command(about = "Create a fixed-amount BOLT11 invoice to receive via an LSPS2 JIT channel")]
 	Bolt11ReceiveViaJitChannel {
@@ -744,20 +740,20 @@ async fn main() {
 				client.bolt11_receive_for_hash(request).await,
 			);
 		},
-		Commands::Bolt11ClaimForHash { preimage, claimable_amount, payment_hash } => {
-			handle_response_result::<_, Bolt11ClaimForHashResponse>(
+		Commands::Bolt11ClaimForId { payment_id, preimage, claimable_amount } => {
+			handle_response_result::<_, Bolt11ClaimForIdResponse>(
 				client
-					.bolt11_claim_for_hash(Bolt11ClaimForHashRequest {
-						payment_hash,
+					.bolt11_claim_for_id(Bolt11ClaimForIdRequest {
+						payment_id,
 						claimable_amount_msat: claimable_amount.map(|a| a.to_msat()),
 						preimage,
 					})
 					.await,
 			);
 		},
-		Commands::Bolt11FailForHash { payment_hash } => {
-			handle_response_result::<_, Bolt11FailForHashResponse>(
-				client.bolt11_fail_for_hash(Bolt11FailForHashRequest { payment_hash }).await,
+		Commands::Bolt11FailForId { payment_id } => {
+			handle_response_result::<_, Bolt11FailForIdResponse>(
+				client.bolt11_fail_for_id(Bolt11FailForIdRequest { payment_id }).await,
 			);
 		},
 		Commands::Bolt11ReceiveViaJitChannel {

ldk-server-client/src/client.rs

@@ -16,8 +16,8 @@ use hyper::body::HttpBody as _;
 use hyper::{Body as HyperBody, Client as HyperClient, Request as HyperRequest, Version};
 use hyper_rustls::{HttpsConnector, HttpsConnectorBuilder};
 use ldk_server_grpc::api::{
-	Bolt11ClaimForHashRequest, Bolt11ClaimForHashResponse, Bolt11FailForHashRequest,
-	Bolt11FailForHashResponse, Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse,
+	Bolt11ClaimForIdRequest, Bolt11ClaimForIdResponse, Bolt11FailForIdRequest,
+	Bolt11FailForIdResponse, Bolt11ReceiveForHashRequest, Bolt11ReceiveForHashResponse,
 	Bolt11ReceiveRequest, Bolt11ReceiveResponse, Bolt11ReceiveVariableAmountViaJitChannelRequest,
 	Bolt11ReceiveVariableAmountViaJitChannelResponse, Bolt11ReceiveViaJitChannelRequest,
 	Bolt11ReceiveViaJitChannelResponse, Bolt11SendRequest, Bolt11SendResponse,
@@ -42,7 +42,7 @@ use ldk_server_grpc::api::{
 	VerifySignatureResponse,
 };
 use ldk_server_grpc::endpoints::{
-	BOLT11_CLAIM_FOR_HASH_PATH, BOLT11_FAIL_FOR_HASH_PATH, BOLT11_RECEIVE_FOR_HASH_PATH,
+	BOLT11_CLAIM_FOR_ID_PATH, BOLT11_FAIL_FOR_ID_PATH, BOLT11_RECEIVE_FOR_HASH_PATH,
 	BOLT11_RECEIVE_PATH, BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_PATH,
 	BOLT11_RECEIVE_VIA_JIT_CHANNEL_PATH, BOLT11_SEND_PATH, BOLT11_SEND_UNDERPAYING_PATH,
 	BOLT12_CREATE_PAYER_PROOF_PATH, BOLT12_RECEIVE_PATH, BOLT12_SEND_PATH, CLOSE_CHANNEL_PATH,
@@ -210,18 +210,18 @@ impl LdkServerClient {
 		self.grpc_unary(&request, BOLT11_RECEIVE_FOR_HASH_PATH).await
 	}
 
-	/// Manually claim a payment for a given payment hash.
-	pub async fn bolt11_claim_for_hash(
-		&self, request: Bolt11ClaimForHashRequest,
-	) -> Result<Bolt11ClaimForHashResponse, LdkServerError> {
-		self.grpc_unary(&request, BOLT11_CLAIM_FOR_HASH_PATH).await
+	/// Manually claim a payment for a given payment ID.
+	pub async fn bolt11_claim_for_id(
+		&self, request: Bolt11ClaimForIdRequest,
+	) -> Result<Bolt11ClaimForIdResponse, LdkServerError> {
+		self.grpc_unary(&request, BOLT11_CLAIM_FOR_ID_PATH).await
 	}
 
-	/// Manually fail a payment for a given payment hash.
-	pub async fn bolt11_fail_for_hash(
-		&self, request: Bolt11FailForHashRequest,
-	) -> Result<Bolt11FailForHashResponse, LdkServerError> {
-		self.grpc_unary(&request, BOLT11_FAIL_FOR_HASH_PATH).await
+	/// Manually fail a payment for a given payment ID.
+	pub async fn bolt11_fail_for_id(
+		&self, request: Bolt11FailForIdRequest,
+	) -> Result<Bolt11FailForIdResponse, LdkServerError> {
+		self.grpc_unary(&request, BOLT11_FAIL_FOR_ID_PATH).await
 	}
 
 	/// Retrieve a new fixed-amount BOLT11 invoice for receiving via an LSPS2 JIT channel.

ldk-server-grpc/src/api.rs

@@ -191,8 +191,8 @@ pub struct Bolt11ReceiveResponse {
 }
 /// Return a BOLT11 payable invoice for a given payment hash.
 /// The inbound payment will NOT be automatically claimed upon arrival.
-/// Instead, the payment will need to be manually claimed by calling `Bolt11ClaimForHash`
-/// or manually failed by calling `Bolt11FailForHash`.
+/// Instead, the payment will need to be manually claimed by calling `Bolt11ClaimForId`
+/// or manually failed by calling `Bolt11FailForId`.
 /// See more:
 /// - <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.receive_for_hash>
 /// - <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.receive_variable_amount_for_hash>
@@ -229,19 +229,18 @@ pub struct Bolt11ReceiveForHashResponse {
 	#[prost(string, tag = "1")]
 	pub invoice: ::prost::alloc::string::String,
 }
-/// Manually claim a payment for a given payment hash with the corresponding preimage.
+/// Manually claim a payment for a given payment ID with the corresponding preimage.
 /// This should be used to claim payments created via `Bolt11ReceiveForHash`.
-/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.claim_for_hash>
+/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.claim_for_id>
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 #[cfg_attr(feature = "serde", serde(default))]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Bolt11ClaimForHashRequest {
-	/// The hex-encoded 32-byte payment hash.
-	/// If provided, it will be used to verify that the preimage matches.
-	#[prost(string, optional, tag = "1")]
-	pub payment_hash: ::core::option::Option<::prost::alloc::string::String>,
+pub struct Bolt11ClaimForIdRequest {
+	/// The hex-encoded 32-byte payment ID from `PaymentClaimable`.
+	#[prost(string, tag = "1")]
+	pub payment_id: ::prost::alloc::string::String,
 	/// The amount in millisatoshi that is claimable.
 	/// If not provided, skips amount verification.
 	#[prost(uint64, optional, tag = "2")]
@@ -250,33 +249,33 @@ pub struct Bolt11ClaimForHashRequest {
 	#[prost(string, tag = "3")]
 	pub preimage: ::prost::alloc::string::String,
 }
-/// The response for the `Bolt11ClaimForHash` RPC. On failure, a gRPC error status is returned.
+/// The response for the `Bolt11ClaimForId` RPC. On failure, a gRPC error status is returned.
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 #[cfg_attr(feature = "serde", serde(default))]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Bolt11ClaimForHashResponse {}
-/// Manually fail a payment for a given payment hash.
+pub struct Bolt11ClaimForIdResponse {}
+/// Manually fail a payment for a given payment ID.
 /// This should be used to reject payments created via `Bolt11ReceiveForHash`.
-/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.fail_for_hash>
+/// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.fail_for_id>
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 #[cfg_attr(feature = "serde", serde(default))]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Bolt11FailForHashRequest {
-	/// The hex-encoded 32-byte payment hash.
+pub struct Bolt11FailForIdRequest {
+	/// The hex-encoded 32-byte payment ID from `PaymentClaimable`.
 	#[prost(string, tag = "1")]
-	pub payment_hash: ::prost::alloc::string::String,
+	pub payment_id: ::prost::alloc::string::String,
 }
-/// The response for the `Bolt11FailForHash` RPC. On failure, a gRPC error status is returned.
+/// The response for the `Bolt11FailForId` RPC. On failure, a gRPC error status is returned.
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 #[cfg_attr(feature = "serde", serde(default))]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Bolt11FailForHashResponse {}
+pub struct Bolt11FailForIdResponse {}
 /// Return a BOLT11 payable invoice that can be used to request and receive a payment via an
 /// LSPS2 just-in-time channel.
 /// See more: <https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.receive_via_jit_channel>

ldk-server-grpc/src/endpoints.rs

@@ -16,8 +16,8 @@ pub const ONCHAIN_RECEIVE_PATH: &str = "OnchainReceive";
 pub const ONCHAIN_SEND_PATH: &str = "OnchainSend";
 pub const BOLT11_RECEIVE_PATH: &str = "Bolt11Receive";
 pub const BOLT11_RECEIVE_FOR_HASH_PATH: &str = "Bolt11ReceiveForHash";
-pub const BOLT11_CLAIM_FOR_HASH_PATH: &str = "Bolt11ClaimForHash";
-pub const BOLT11_FAIL_FOR_HASH_PATH: &str = "Bolt11FailForHash";
+pub const BOLT11_CLAIM_FOR_ID_PATH: &str = "Bolt11ClaimForId";
+pub const BOLT11_FAIL_FOR_ID_PATH: &str = "Bolt11FailForId";
 pub const BOLT11_RECEIVE_VIA_JIT_CHANNEL_PATH: &str = "Bolt11ReceiveViaJitChannel";
 pub const BOLT11_RECEIVE_VARIABLE_AMOUNT_VIA_JIT_CHANNEL_PATH: &str =
 	"Bolt11ReceiveVariableAmountViaJitChannel";

ldk-server-grpc/src/proto/api.proto

@@ -157,8 +157,8 @@ message Bolt11ReceiveResponse {
 
 // Return a BOLT11 payable invoice for a given payment hash.
 // The inbound payment will NOT be automatically claimed upon arrival.
-// Instead, the payment will need to be manually claimed by calling `Bolt11ClaimForHash`
-// or manually failed by calling `Bolt11FailForHash`.
+// Instead, the payment will need to be manually claimed by calling `Bolt11ClaimForId`
+// or manually failed by calling `Bolt11FailForId`.
 // See more:
 // - https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.receive_for_hash
 // - https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.receive_variable_amount_for_hash
@@ -187,14 +187,13 @@ message Bolt11ReceiveForHashResponse {
   string invoice = 1;
 }
 
-// Manually claim a payment for a given payment hash with the corresponding preimage.
+// Manually claim a payment for a given payment ID with the corresponding preimage.
 // This should be used to claim payments created via `Bolt11ReceiveForHash`.
-// See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.claim_for_hash
-message Bolt11ClaimForHashRequest {
+// See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.claim_for_id
+message Bolt11ClaimForIdRequest {
 
-  // The hex-encoded 32-byte payment hash.
-  // If provided, it will be used to verify that the preimage matches.
-  optional string payment_hash = 1;
+  // The hex-encoded 32-byte payment ID from `PaymentClaimable`.
+  string payment_id = 1;
 
   // The amount in millisatoshi that is claimable.
   // If not provided, skips amount verification.
@@ -204,20 +203,20 @@ message Bolt11ClaimForHashRequest {
   string preimage = 3;
 }
 
-// The response for the `Bolt11ClaimForHash` RPC. On failure, a gRPC error status is returned.
-message Bolt11ClaimForHashResponse {}
+// The response for the `Bolt11ClaimForId` RPC. On failure, a gRPC error status is returned.
+message Bolt11ClaimForIdResponse {}
 
-// Manually fail a payment for a given payment hash.
+// Manually fail a payment for a given payment ID.
 // This should be used to reject payments created via `Bolt11ReceiveForHash`.
-// See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.fail_for_hash
-message Bolt11FailForHashRequest {
+// See more: https://docs.rs/ldk-node/latest/ldk_node/payment/struct.Bolt11Payment.html#method.fail_for_id
+message Bolt11FailForIdRequest {
 
-  // The hex-encoded 32-byte payment hash.
-  string payment_hash = 1;
+  // The hex-encoded 32-byte payment ID from `PaymentClaimable`.
+  string payment_id = 1;
 }
 
-// The response for the `Bolt11FailForHash` RPC. On failure, a gRPC error status is returned.
-message Bolt11FailForHashResponse {}
+// The response for the `Bolt11FailForId` RPC. On failure, a gRPC error status is returned.
+message Bolt11FailForIdResponse {}
 
 // Return a BOLT11 payable invoice that can be used to request and receive a payment via an
 // LSPS2 just-in-time channel.
@@ -968,10 +967,10 @@ service LightningNode {
   rpc Bolt11Receive(Bolt11ReceiveRequest) returns (Bolt11ReceiveResponse);
   // Return a BOLT11 payable invoice for a given payment hash.
   rpc Bolt11ReceiveForHash(Bolt11ReceiveForHashRequest) returns (Bolt11ReceiveForHashResponse);
-  // Manually claim a payment for a given payment hash.
-  rpc Bolt11ClaimForHash(Bolt11ClaimForHashRequest) returns (Bolt11ClaimForHashResponse);
-  // Manually fail a payment for a given payment hash.
-  rpc Bolt11FailForHash(Bolt11FailForHashRequest) returns (Bolt11FailForHashResponse);
+  // Manually claim a payment for a given payment ID.
+  rpc Bolt11ClaimForId(Bolt11ClaimForIdRequest) returns (Bolt11ClaimForIdResponse);
+  // Manually fail a payment for a given payment ID.
+  rpc Bolt11FailForId(Bolt11FailForIdRequest) returns (Bolt11FailForIdResponse);
   // Return a BOLT11 invoice for receiving via a JIT channel.
   rpc Bolt11ReceiveViaJitChannel(Bolt11ReceiveViaJitChannelRequest) returns (Bolt11ReceiveViaJitChannelResponse);
   // Return a variable-amount BOLT11 invoice for receiving via a JIT channel.