Remove block fee, disallow empty blocks. (#3850)

## Motivation

If all incoming messages are covered by grants, the chain owner should
not have any fees left to pay.

## Proposal

Remove the base block fee. Disallow empty blocks.

## Test Plan

TBD

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

- Part of #3841.
- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

---------

Signed-off-by: deuszx <[email protected]>
Co-authored-by: deuszx <[email protected]>
Co-authored-by: deuszx <[email protected]>

Author: afck

.github/workflows/rust.yml

@@ -61,10 +61,11 @@ jobs:
         mkdir /tmp/local-linera-net
         cargo run --features storage-service --bin linera -- net up --storage service:tcp:$LINERA_STORAGE_SERVICE:table --policy-config testnet --path /tmp/local-linera-net --validators 4 --shards 4 &
     - name: Create two epochs and run the faucet
+      # See https://github.com/linera-io/linera-protocol/pull/2835 for details.
       run: |
         cargo build --bin linera
-        cargo run --bin linera -- resource-control-policy --block 0.0000001
-        cargo run --bin linera -- resource-control-policy --block 0.000000
+        cargo run --bin linera -- resource-control-policy --http-request-timeout-ms 1000
+        cargo run --bin linera -- resource-control-policy --http-request-timeout-ms 500
         cargo run --bin linera -- faucet --amount 1000 --port 8079 &
     - name: Run the remote-net tests
       run: |

CLI.md

@@ -475,7 +475,6 @@ View or update the resource control policy
 
 ###### **Options:**
 
-* `--block <BLOCK>` — Set the base price for creating a block
 * `--wasm-fuel-unit <WASM_FUEL_UNIT>` — Set the price per unit of Wasm fuel
 * `--evm-fuel-unit <EVM_FUEL_UNIT>` — Set the price per unit of EVM fuel
 * `--read-operation <READ_OPERATION>` — Set the price per read operation
@@ -537,7 +536,6 @@ Create genesis configuration for a Linera deployment. Create initial user chains
 
   Possible values: `no-fees`, `testnet`
 
-* `--block-price <BLOCK_PRICE>` — Set the base price for creating a block. (This will overwrite value from `--policy-config`)
 * `--wasm-fuel-unit-price <WASM_FUEL_UNIT_PRICE>` — Set the price per unit of Wasm fuel. (This will overwrite value from `--policy-config`)
 * `--evm-fuel-unit-price <EVM_FUEL_UNIT_PRICE>` — Set the price per unit of EVM fuel. (This will overwrite value from `--policy-config`)
 * `--read-operation-price <READ_OPERATION_PRICE>` — Set the price per read operation. (This will overwrite value from `--policy-config`)

examples/native-fungible/tests/transfers.rs

@@ -43,7 +43,10 @@ async fn chain_balance_transfers() {
         })
         .await;
 
-    assert_eq!(recipient_chain.chain_balance().await, transfer_amount);
+    // At the start, chain has balance of 10 tokens.
+    // After the transfer, it should have 11 tokens.
+    let expected_balance = Amount::from_tokens(10) + transfer_amount;
+    assert_eq!(recipient_chain.chain_balance().await, expected_balance);
     assert_balances(&recipient_chain, []).await;
 }
 

linera-base/src/data_types.rs

@@ -935,6 +935,19 @@ impl ApplicationPermissions {
         }
     }
 
+    /// Creates new `ApplicationPermissions` where the given applications are the only ones
+    /// whose operations are allowed and mandatory, and they can also close the chain.
+    pub fn new_multiple(app_ids: Vec<ApplicationId>) -> Self {
+        Self {
+            execute_operations: Some(app_ids.clone()),
+            mandatory_applications: app_ids.clone(),
+            close_chain: app_ids.clone(),
+            change_application_permissions: app_ids.clone(),
+            call_service_as_oracle: Some(app_ids.clone()),
+            make_http_requests: Some(app_ids),
+        }
+    }
+
     /// Returns whether operations with the given application ID are allowed on this chain.
     pub fn can_execute_operations(&self, app_id: &GenericApplicationId) -> bool {
         match (app_id, &self.execute_operations) {

linera-chain/src/chain.rs

@@ -708,7 +708,10 @@ where
         );
 
         chain.system.timestamp.set(block.timestamp);
-
+        ensure!(
+            !block.incoming_bundles.is_empty() || !block.operations.is_empty(),
+            ChainError::EmptyBlock
+        );
         let (_, committee) = chain
             .system
             .current_committee()

linera-chain/src/lib.rs

@@ -152,6 +152,8 @@ pub enum ChainError {
     OwnerWeightError(#[from] WeightedError),
     #[error("Closed chains cannot have operations, accepted messages or empty blocks")]
     ClosedChain,
+    #[error("Empty blocks are not allowed")]
+    EmptyBlock,
     #[error("All operations on this chain must be from one of the following applications: {0:?}")]
     AuthorizedApplications(Vec<ApplicationId>),
     #[error("Missing operations or messages from mandatory applications: {0:?}")]

linera-chain/src/test/mod.rs

@@ -78,6 +78,9 @@ pub trait BlockTestExt: Sized {
     /// Returns the block with the specified epoch.
     fn with_epoch(self, epoch: impl Into<Epoch>) -> Self;
 
+    /// Returns the block with the burn operation appended at the end.
+    fn with_burn(self, amount: Amount) -> Self;
+
     /// Returns a block proposal in the first round in a default ownership configuration
     /// (`Round::MultiLeader(0)`) without any hashed certificate values or validated block.
     async fn into_first_proposal(
@@ -121,6 +124,14 @@ impl BlockTestExt for ProposedBlock {
         self.with_transfer(AccountOwner::CHAIN, Recipient::chain(chain_id), amount)
     }
 
+    fn with_burn(self, amount: Amount) -> Self {
+        self.with_operation(SystemOperation::Transfer {
+            owner: AccountOwner::CHAIN,
+            recipient: Recipient::Burn,
+            amount,
+        })
+    }
+
     fn with_incoming_bundle(mut self, incoming_bundle: IncomingBundle) -> Self {
         self.incoming_bundles.push(incoming_bundle);
         self

linera-chain/src/unit_tests/chain_tests.rs

@@ -109,6 +109,14 @@ impl TestEnvironment {
     fn make_app_description(&self) -> (ApplicationDescription, Blob, Blob) {
         let contract = Bytecode::new(b"contract".into());
         let service = Bytecode::new(b"service".into());
+        self.make_app_from_bytecodes(contract, service)
+    }
+
+    fn make_app_from_bytecodes(
+        &self,
+        contract: Bytecode,
+        service: Bytecode,
+    ) -> (ApplicationDescription, Blob, Blob) {
         let contract_blob = Blob::new_contract_bytecode(contract.compress());
         let service_blob = Blob::new_service_bytecode(service.compress());
         let vm_runtime = VmRuntime::Wasm;
@@ -254,8 +262,17 @@ async fn test_application_permissions() -> anyhow::Result<()> {
     let application_id = ApplicationId::from(&app_description);
     let application = MockApplication::default();
 
+    let (another_app, another_contract, another_service) = env.make_app_from_bytecodes(
+        Bytecode::new(b"contractB".into()),
+        Bytecode::new(b"serviceB".into()),
+    );
+    let another_app_id = ApplicationId::from(&another_app);
+
     let config = InitialChainConfig {
-        application_permissions: ApplicationPermissions::new_single(application_id),
+        application_permissions: ApplicationPermissions::new_multiple(vec![
+            application_id,
+            another_app_id,
+        ]),
         ..env.make_open_chain_config()
     };
     let chain_desc = env.make_child_chain_description_with_config(3, config);
@@ -267,6 +284,10 @@ async fn test_application_permissions() -> anyhow::Result<()> {
     extra
         .user_contracts()
         .insert(application_id, application.clone().into());
+    extra
+        .user_contracts()
+        .insert(another_app_id, application.clone().into());
+
     extra.add_blobs(env.description_blobs()).await?;
     extra
         .add_blobs([
@@ -275,6 +296,13 @@ async fn test_application_permissions() -> anyhow::Result<()> {
             Blob::new_application_description(&app_description),
         ])
         .await?;
+    extra
+        .add_blobs([
+            another_contract,
+            another_service,
+            Blob::new_application_description(&another_app),
+        ])
+        .await?;
 
     // Initialize the chain, with a chain application.
     chain.ensure_is_active(time).await?;
@@ -285,20 +313,31 @@ async fn test_application_permissions() -> anyhow::Result<()> {
         .execute_block(&invalid_block, time, None, &[], None)
         .await;
     assert_matches!(result, Err(ChainError::AuthorizedApplications(app_ids))
-        if app_ids == vec![application_id]
+        if app_ids == vec![application_id, another_app_id]
     );
 
     // After registering, an app operation can already be used in the first block.
     application.expect_call(ExpectedCall::execute_operation(|_, _| Ok(vec![])));
     application.expect_call(ExpectedCall::default_finalize());
+    application.expect_call(ExpectedCall::execute_operation(|_, _| Ok(vec![])));
+    application.expect_call(ExpectedCall::default_finalize());
     let app_operation = Operation::User {
         application_id,
         bytes: b"foo".to_vec(),
     };
-    let valid_block = make_first_block(chain_id).with_operation(app_operation.clone());
+    let another_app_operation = Operation::User {
+        application_id: another_app_id,
+        bytes: b"bar".to_vec(),
+    };
+
+    let valid_block = make_first_block(chain_id)
+        .with_operation(app_operation.clone())
+        .with_operation(another_app_operation.clone());
+
     let outcome = chain
         .execute_block(&valid_block, time, None, &[], None)
         .await?;
+
     let value = ConfirmedBlock::new(outcome.with(valid_block));
     chain.apply_confirmed_block(&value, time).await?;
 
@@ -310,22 +349,24 @@ async fn test_application_permissions() -> anyhow::Result<()> {
         .execute_block(&invalid_block, time, None, &[], None)
         .await;
     assert_matches!(result, Err(ChainError::AuthorizedApplications(app_ids))
-        if app_ids == vec![application_id]
+        if app_ids == vec![application_id, another_app_id]
     );
-
-    // Also, blocks without an application operation or incoming message are forbidden.
-    let invalid_block = make_child_block(&value);
+    // Also, blocks without all authorized applications operation, or incoming message, are forbidden.
+    let invalid_block = make_child_block(&value).with_operation(another_app_operation.clone());
     let result = chain
         .execute_block(&invalid_block, time, None, &[], None)
         .await;
     assert_matches!(result, Err(ChainError::MissingMandatoryApplications(app_ids))
         if app_ids == vec![application_id]
     );
-
     // But app operations continue to work.
     application.expect_call(ExpectedCall::execute_operation(|_, _| Ok(vec![])));
     application.expect_call(ExpectedCall::default_finalize());
-    let valid_block = make_child_block(&value).with_operation(app_operation);
+    application.expect_call(ExpectedCall::execute_operation(|_, _| Ok(vec![])));
+    application.expect_call(ExpectedCall::default_finalize());
+    let valid_block = make_child_block(&value)
+        .with_operation(app_operation.clone())
+        .with_operation(another_app_operation.clone());
     let outcome = chain
         .execute_block(&valid_block, time, None, &[], None)
         .await?;

linera-client/src/client_options.rs

@@ -287,8 +287,6 @@ pub enum ResourceControlPolicyConfig {
     #[cfg(with_testing)]
     OnlyFuel,
     #[cfg(with_testing)]
-    FuelAndBlock,
-    #[cfg(with_testing)]
     AllCategories,
 }
 
@@ -300,8 +298,6 @@ impl ResourceControlPolicyConfig {
             #[cfg(with_testing)]
             ResourceControlPolicyConfig::OnlyFuel => ResourceControlPolicy::only_fuel(),
             #[cfg(with_testing)]
-            ResourceControlPolicyConfig::FuelAndBlock => ResourceControlPolicy::fuel_and_block(),
-            #[cfg(with_testing)]
             ResourceControlPolicyConfig::AllCategories => ResourceControlPolicy::all_categories(),
         }
     }

linera-core/src/client/mod.rs

@@ -2515,6 +2515,13 @@ impl<Env: Environment> ChainClient<Env> {
         owner: AccountOwner,
     ) -> Result<(Amount, Option<Amount>), ChainClientError> {
         let incoming_bundles = self.pending_message_bundles().await?;
+        // Since we disallow empty blocks, and there is no incoming messages,
+        // that could change it, we query for the balance immediately.
+        if incoming_bundles.is_empty() {
+            let chain_balance = self.local_balance().await?;
+            let owner_balance = self.local_owner_balance(owner).await?;
+            return Ok((chain_balance, Some(owner_balance)));
+        }
         let (previous_block_hash, height, timestamp) = {
             let state = self.state();
             (
@@ -2554,7 +2561,7 @@ impl<Env: Environment> ChainClient<Env> {
                     ChainExecutionContext::Block
                 ) if matches!(
                     **execution_error,
-                    ExecutionError::InsufficientFundingForFees { .. }
+                    ExecutionError::FeesExceedFunding { .. }
                 )
             ) =>
             {