withlist to no pay only in success

Author: iamyxsh

pallets/signet/src/lib.rs

@@ -1,4 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::useless_conversion)]
 
 use ethereum::{AccessListItem, EIP1559TransactionMessage, TransactionAction};
 use frame_support::{
@@ -412,12 +413,12 @@ pub mod pallet {
 
 		/// Respond to signature requests (batch support)
 		#[pallet::call_index(4)]
-		#[pallet::weight((<T as Config>::WeightInfo::respond(), Pays::No))]
+		#[pallet::weight(<T as Config>::WeightInfo::respond())]
 		pub fn respond(
 			origin: OriginFor<T>,
 			request_ids: BoundedVec<[u8; 32], ConstU32<MAX_BATCH_SIZE>>,
 			signatures: BoundedVec<Signature, ConstU32<MAX_BATCH_SIZE>>,
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let responder = ensure_signed(origin)?;
 			ensure!(Signers::<T>::contains_key(&responder), Error::<T>::NotAuthorizedSigner);
 
@@ -431,16 +432,16 @@ pub mod pallet {
 				});
 			}
 
-			Ok(())
+			Ok(Pays::No.into())
 		}
 
 		/// Report signature generation errors (batch support)
 		#[pallet::call_index(5)]
-		#[pallet::weight((<T as Config>::WeightInfo::respond_error(), Pays::No))]
+		#[pallet::weight(<T as Config>::WeightInfo::respond_error())]
 		pub fn respond_error(
 			origin: OriginFor<T>,
 			errors: BoundedVec<ErrorResponse, ConstU32<MAX_BATCH_SIZE>>,
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let responder = ensure_signed(origin)?;
 			ensure!(Signers::<T>::contains_key(&responder), Error::<T>::NotAuthorizedSigner);
 
@@ -452,18 +453,18 @@ pub mod pallet {
 				});
 			}
 
-			Ok(())
+			Ok(Pays::No.into())
 		}
 
 		/// Provide a read response with signature
 		#[pallet::call_index(6)]
-		#[pallet::weight((<T as Config>::WeightInfo::respond_bidirectional(), Pays::No))]
+		#[pallet::weight(<T as Config>::WeightInfo::respond_bidirectional())]
 		pub fn respond_bidirectional(
 			origin: OriginFor<T>,
 			request_id: [u8; 32],
 			serialized_output: BoundedVec<u8, ConstU32<MAX_SERIALIZED_OUTPUT_LENGTH>>,
 			signature: Signature,
-		) -> DispatchResult {
+		) -> DispatchResultWithPostInfo {
 			let responder = ensure_signed(origin)?;
 			ensure!(Signers::<T>::contains_key(&responder), Error::<T>::NotAuthorizedSigner);
 
@@ -474,7 +475,7 @@ pub mod pallet {
 				signature,
 			});
 
-			Ok(())
+			Ok(Pays::No.into())
 		}
 
 		/// Pause the signet so that no new signing requests can be made.

pallets/signet/src/tests/signer_allowlist.rs

@@ -218,42 +218,89 @@ fn respond_should_fail_when_signer_is_removed() {
 }
 
 // -----------------------------------------------------------------------------
-// feeless (Pays::No) annotation
+// fee: refunded on success, charged on failure
 // -----------------------------------------------------------------------------
 
 #[test]
-fn respond_should_be_feeless_when_called() {
+fn respond_should_refund_fee_when_successful() {
 	new_test_ext().execute_with(|| {
-		let call = RuntimeCall::Signet(crate::Call::respond {
-			request_ids: bounded_array::<100>(vec![[1u8; 32]]),
-			signatures: bounded_sig::<100>(vec![create_test_signature()]),
-		});
-		assert_eq!(call.get_dispatch_info().pays_fee, Pays::No);
+		assert_ok!(Signet::add_signer(RuntimeOrigin::root(), SIGNER));
+
+		let info = Signet::respond(
+			RuntimeOrigin::signed(SIGNER),
+			bounded_array::<100>(vec![[1u8; 32]]),
+			bounded_sig::<100>(vec![create_test_signature()]),
+		)
+		.expect("respond should succeed");
+
+		assert_eq!(info.pays_fee, Pays::No);
 	});
 }
 
 #[test]
-fn respond_error_should_be_feeless_when_called() {
+fn respond_error_should_refund_fee_when_successful() {
 	new_test_ext().execute_with(|| {
-		let call = RuntimeCall::Signet(crate::Call::respond_error {
-			errors: bounded_err::<100>(vec![ErrorResponse {
+		assert_ok!(Signet::add_signer(RuntimeOrigin::root(), SIGNER));
+
+		let info = Signet::respond_error(
+			RuntimeOrigin::signed(SIGNER),
+			bounded_err::<100>(vec![ErrorResponse {
 				request_id: [1u8; 32],
 				error_message: bounded_u8::<1024>(b"boom".to_vec()),
 			}]),
-		});
-		assert_eq!(call.get_dispatch_info().pays_fee, Pays::No);
+		)
+		.expect("respond_error should succeed");
+
+		assert_eq!(info.pays_fee, Pays::No);
 	});
 }
 
 #[test]
-fn respond_bidirectional_should_be_feeless_when_called() {
+fn respond_bidirectional_should_refund_fee_when_successful() {
 	new_test_ext().execute_with(|| {
-		let call = RuntimeCall::Signet(crate::Call::respond_bidirectional {
-			request_id: [1u8; 32],
-			serialized_output: bounded_u8::<65536>(b"out".to_vec()),
-			signature: create_test_signature(),
-		});
-		assert_eq!(call.get_dispatch_info().pays_fee, Pays::No);
+		assert_ok!(Signet::add_signer(RuntimeOrigin::root(), SIGNER));
+
+		let info = Signet::respond_bidirectional(
+			RuntimeOrigin::signed(SIGNER),
+			[1u8; 32],
+			bounded_u8::<65536>(b"out".to_vec()),
+			create_test_signature(),
+		)
+		.expect("respond_bidirectional should succeed");
+
+		assert_eq!(info.pays_fee, Pays::No);
+	});
+}
+
+#[test]
+fn respond_should_charge_fee_when_unauthorized() {
+	new_test_ext().execute_with(|| {
+		let err = Signet::respond(
+			RuntimeOrigin::signed(OUTSIDER),
+			bounded_array::<100>(vec![[1u8; 32]]),
+			bounded_sig::<100>(vec![create_test_signature()]),
+		)
+		.expect_err("respond should fail for an unauthorized caller");
+
+		assert_eq!(err.error, Error::<Test>::NotAuthorizedSigner.into());
+		assert_eq!(err.post_info.pays_fee, Pays::Yes);
+	});
+}
+
+#[test]
+fn respond_should_charge_fee_when_input_lengths_mismatch() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Signet::add_signer(RuntimeOrigin::root(), SIGNER));
+
+		let err = Signet::respond(
+			RuntimeOrigin::signed(SIGNER),
+			bounded_array::<100>(vec![[1u8; 32], [2u8; 32]]),
+			bounded_sig::<100>(vec![create_test_signature()]),
+		)
+		.expect_err("respond should fail on length mismatch");
+
+		assert_eq!(err.error, Error::<Test>::InvalidInputLength.into());
+		assert_eq!(err.post_info.pays_fee, Pays::Yes);
 	});
 }
 

scripts/signet-feeless-test/README.md

@@ -1,8 +1,10 @@
 # signet-feeless-test
 
-Chopsticks e2e for the allowlist-gated, feeless `signet.respond` flow: an
-authorized signer holding only the existential deposit (1 HDX) can call
-`respond` without paying a fee, and a non-allowlisted account is rejected.
+Chopsticks e2e for the allowlist-gated `signet.respond` flow: the fee is locked
+upfront and refunded when the call succeeds, otherwise charged. An authorized
+signer's successful `respond` costs nothing (fee refunded), while a
+non-allowlisted account fails and is charged. The caller must hold enough HDX to
+lock the fee.
 
 Mirrors the pallet unit tests in `pallets/signet/src/tests/signer_allowlist.rs`.
 

scripts/signet-feeless-test/signet-feeless.test.ts

@@ -20,7 +20,10 @@ const SIGNATURE = {
 	recoveryId: 0,
 };
 
-describe('signet feeless respond (allowlist-gated)', () => {
+// Existential deposit plus enough headroom to lock one respond fee.
+const FUND = ED + 10_000_000_000_000n;
+
+describe('signet respond (lock / refund-on-success)', () => {
 	let api: ApiPromise;
 	let provider: WsProvider;
 	let signer: KeyringPair;
@@ -34,9 +37,8 @@ describe('signet feeless respond (allowlist-gated)', () => {
 
 		await executeAsRootViaScheduler(api, provider, api.tx.signet.addSigner(signer.address));
 
-		// Fund both with exactly the existential deposit — no gas buffer.
-		await setNativeBalance(provider, signer.address, ED);
-		await setNativeBalance(provider, outsider.address, ED);
+		await setNativeBalance(provider, signer.address, FUND);
+		await setNativeBalance(provider, outsider.address, FUND);
 	}, 600000);
 
 	afterAll(async () => {
@@ -48,12 +50,12 @@ describe('signet feeless respond (allowlist-gated)', () => {
 		expect((entry as any).isSome).toBe(true);
 	});
 
-	it('respond should be annotated Pays::No (zero partial fee)', async () => {
+	it('respond should predict a non-zero fee (locked upfront)', async () => {
 		const info = await api.tx.signet.respond([REQUEST_ID], [SIGNATURE]).paymentInfo(signer.address);
-		expect((info as any).partialFee.toBigInt()).toBe(0n);
+		expect((info as any).partialFee.toBigInt()).toBeGreaterThan(0n);
 	});
 
-	it('respond should succeed for an ED-only signer and not charge a fee', async () => {
+	it('respond should refund the fee when successful', async () => {
 		const before = await freeBalance(api, signer.address);
 
 		const events = await submitAndMine(api, provider, api.tx.signet.respond([REQUEST_ID], [SIGNATURE]), signer);
@@ -63,10 +65,11 @@ describe('signet feeless respond (allowlist-gated)', () => {
 
 		const after = await freeBalance(api, signer.address);
 		expect(after).toBe(before);
-		expect(after).toBe(ED);
 	}, 300000);
 
-	it('respond should be rejected for a non-allowlisted account', async () => {
+	it('respond should charge the fee when the caller is not allowlisted', async () => {
+		const before = await freeBalance(api, outsider.address);
+
 		const events = await submitAndMine(api, provider, api.tx.signet.respond([REQUEST_ID], [SIGNATURE]), outsider);
 
 		const failed = findEvent(events, 'system', 'ExtrinsicFailed');
@@ -75,5 +78,8 @@ describe('signet feeless respond (allowlist-gated)', () => {
 		const err = moduleErrorName(api, failed);
 		expect(err.section).toBe('signet');
 		expect(err.name).toBe('NotAuthorizedSigner');
+
+		const after = await freeBalance(api, outsider.address);
+		expect(after).toBeLessThan(before);
 	}, 300000);
 });