testnet PoW

.changelog/unreleased/improvements/962-basic-fee.md

@@ -0,0 +1,2 @@
+- Added a basic fee implementation for testnet.
+  ([#962](https://github.com/anoma/namada/pull/962))

.changelog/unreleased/improvements/969-testnet-pow.md

@@ -0,0 +1,4 @@
+- Added an optional PoW challenge to the wrapper transactions for testnets,
+  to allow to submit transactions without having enough balance to cover
+  the minimum transaction fee and to withdraw tokens from a faucet account.
+  ([#969](https://github.com/anoma/namada/pull/969))

.changelog/unreleased/improvements/975-max-block-size.md

@@ -0,0 +1,2 @@
+- Add a max_proposal_bytes parameter to the ledger.
+  ([#975](https://github.com/anoma/namada/pull/975))

Makefile

@@ -49,6 +49,9 @@ check-abcipp:
 		--no-default-features \
 		--features "abcipp ibc-mocks-abcipp testing"
 
+check-mainnet:
+	$(cargo) check --workspace --features "mainnet"
+
 clippy-wasm = $(cargo) +$(nightly) clippy --manifest-path $(wasm)/Cargo.toml --all-targets -- -D warnings
 
 clippy:
@@ -76,6 +79,9 @@ clippy-abcipp:
 	make -C $(wasms) clippy && \
 	$(foreach wasm,$(wasm_templates),$(clippy-wasm) && ) true
 
+clippy-mainnet:
+	$(cargo) +$(nightly) clippy --all-targets --features "mainnet" -- -D warnings
+
 clippy-fix:
 	$(cargo) +$(nightly) clippy --fix -Z unstable-options --all-targets --allow-dirty --allow-staged
 
@@ -143,6 +149,13 @@ test-unit:
 			--skip e2e \
 			-Z unstable-options --report-time
 
+test-unit-mainnet:
+	$(cargo) test \
+		--features "mainnet" \
+		$(TEST_FILTER) -- \
+		--skip e2e \
+		-Z unstable-options --report-time
+
 test-unit-debug:
 	$(debug-cargo) test \
 			$(TEST_FILTER) -- \

apps/Cargo.toml

@@ -41,6 +41,9 @@ path = "src/bin/namada-wallet/main.rs"
 
 [features]
 default = ["std", "abciplus"]
+mainnet = [
+  "namada/mainnet",
+]
 dev = ["namada/dev"]
 std = ["ed25519-consensus/std", "rand/std", "rand_core/std"]
 # for integration tests and test utilies

apps/src/lib/client/rpc.rs

@@ -22,6 +22,8 @@ use masp_primitives::primitives::ViewingKey;
 use masp_primitives::sapling::Node;
 use masp_primitives::transaction::components::Amount;
 use masp_primitives::zip32::ExtendedFullViewingKey;
+#[cfg(not(feature = "mainnet"))]
+use namada::core::ledger::testnet_pow;
 use namada::ledger::events::Event;
 use namada::ledger::governance::parameters::GovParams;
 use namada::ledger::governance::storage as gov_storage;
@@ -389,15 +391,23 @@ fn extract_payload(
             let privkey = <EllipticCurve as PairingEngine>::G2Affine::prime_subgroup_generator();
             extract_payload(
                 Tx::from(match wrapper_tx.decrypt(privkey) {
-                    Ok(tx) => DecryptedTx::Decrypted(tx),
+                    Ok(tx) => DecryptedTx::Decrypted {
+                        tx,
+                        #[cfg(not(feature = "mainnet"))]
+                        has_valid_pow: false,
+                    },
                     _ => DecryptedTx::Undecryptable(wrapper_tx.clone()),
                 }),
                 wrapper,
                 transfer,
             );
             *wrapper = Some(wrapper_tx);
         }
-        Ok(TxType::Decrypted(DecryptedTx::Decrypted(tx))) => {
+        Ok(TxType::Decrypted(DecryptedTx::Decrypted {
+            tx,
+            #[cfg(not(feature = "mainnet"))]
+                has_valid_pow: _,
+        })) => {
             let empty_vec = vec![];
             let tx_data = tx.data.as_ref().unwrap_or(&empty_vec);
             let _ = SignedTxData::try_from_slice(tx_data).map(|signed| {
@@ -2005,6 +2015,38 @@ pub async fn known_address(
     }
 }
 
+#[cfg(not(feature = "mainnet"))]
+/// Check if the given address is a testnet faucet account address.
+pub async fn is_faucet_account(
+    address: &Address,
+    ledger_address: TendermintAddress,
+) -> bool {
+    let client = HttpClient::new(ledger_address).unwrap();
+    unwrap_client_response(RPC.vp().is_faucet(&client, address).await)
+}
+
+#[cfg(not(feature = "mainnet"))]
+/// Get faucet account address, if any is setup for the network.
+pub async fn get_faucet_address(
+    ledger_address: TendermintAddress,
+) -> Option<Address> {
+    let client = HttpClient::new(ledger_address).unwrap();
+    unwrap_client_response(RPC.vp().get_faucet_address(&client).await)
+}
+
+#[cfg(not(feature = "mainnet"))]
+/// Obtain a PoW challenge for a withdrawal from a testnet faucet account, if
+/// any is setup for the network.
+pub async fn get_testnet_pow_challenge(
+    source: Address,
+    ledger_address: TendermintAddress,
+) -> testnet_pow::Challenge {
+    let client = HttpClient::new(ledger_address).unwrap();
+    unwrap_client_response(
+        RPC.vp().testnet_pow_challenge(&client, source).await,
+    )
+}
+
 /// Accumulate slashes starting from `epoch_start` until (optionally)
 /// `withdraw_epoch` and apply them to the token amount `delta`.
 fn apply_slashes(

apps/src/lib/client/signing.rs

@@ -6,13 +6,16 @@ use namada::proto::Tx;
 use namada::types::address::{Address, ImplicitAddress};
 use namada::types::key::*;
 use namada::types::storage::Epoch;
-use namada::types::transaction::{hash_tx, Fee, WrapperTx};
+use namada::types::token;
+use namada::types::token::Amount;
+use namada::types::transaction::{hash_tx, Fee, WrapperTx, MIN_FEE};
 
 use super::rpc;
 use crate::cli::context::{WalletAddress, WalletKeypair};
 use crate::cli::{self, args, Context};
 use crate::client::tendermint_rpc_types::TxBroadcastData;
 use crate::facade::tendermint_config::net::Address as TendermintAddress;
+use crate::facade::tendermint_rpc::HttpClient;
 use crate::wallet::Wallet;
 
 /// Find the public key for the given address and try to load the keypair
@@ -145,6 +148,7 @@ pub async fn sign_tx(
     tx: Tx,
     args: &args::Tx,
     default: TxSigningKey,
+    #[cfg(not(feature = "mainnet"))] requires_pow: bool,
 ) -> (Context, TxBroadcastData) {
     let keypair = tx_signer(&mut ctx, args, default).await;
     let tx = tx.sign(&keypair);
@@ -156,7 +160,16 @@ pub async fn sign_tx(
     let broadcast_data = if args.dry_run {
         TxBroadcastData::DryRun(tx)
     } else {
-        sign_wrapper(&ctx, args, epoch, tx, &keypair).await
+        sign_wrapper(
+            &ctx,
+            args,
+            epoch,
+            tx,
+            &keypair,
+            #[cfg(not(feature = "mainnet"))]
+            requires_pow,
+        )
+        .await
     };
     (ctx, broadcast_data)
 }
@@ -170,19 +183,63 @@ pub async fn sign_wrapper(
     epoch: Epoch,
     tx: Tx,
     keypair: &common::SecretKey,
+    #[cfg(not(feature = "mainnet"))] requires_pow: bool,
 ) -> TxBroadcastData {
+    let fee_amount = Amount::from(MIN_FEE);
+    let fee_token = ctx.get(&args.fee_token);
+    let source = Address::from(&keypair.ref_to());
+    let balance_key = token::balance_key(&fee_token, &source);
+    let client = HttpClient::new(args.ledger_address.clone()).unwrap();
+    let balance =
+        rpc::query_storage_value::<token::Amount>(&client, &balance_key)
+            .await
+            .unwrap_or_default();
+    if balance < fee_amount {
+        eprintln!(
+            "The wrapper transaction source doesn't have enough balance to \
+             pay fee {fee_amount}, got {balance}."
+        );
+        if !args.force && cfg!(feature = "mainnet") {
+            cli::safe_exit(1);
+        }
+    }
+
+    #[cfg(not(feature = "mainnet"))]
+    // A PoW solution can be used to allow zero-fee testnet transactions
+    let pow_solution: Option<namada::core::ledger::testnet_pow::Solution> = {
+        // If the address derived from the keypair doesn't have enough balance
+        // to pay for the fee, allow to find a PoW solution instead.
+        if requires_pow || balance < fee_amount {
+            println!("The transaction requires to a PoW challenge.");
+            // Obtain a PoW challenge for faucet withdrawal
+            let challenge = rpc::get_testnet_pow_challenge(
+                source,
+                args.ledger_address.clone(),
+            )
+            .await;
+
+            // Solve the solution, this blocks until a solution is found
+            let solution = challenge.solve();
+            Some(solution)
+        } else {
+            None
+        }
+    };
+
     let tx = {
         WrapperTx::new(
             Fee {
-                amount: args.fee_amount,
-                token: ctx.get(&args.fee_token),
+                amount: fee_amount,
+                token: fee_token,
             },
             keypair,
             epoch,
             args.gas_limit.clone(),
             tx,
             // TODO: Actually use the fetched encryption key
             Default::default(),
+            #[cfg(not(feature = "mainnet"))]
+            pow_solution,
         )
     };