Set transaction size limit

Cargo.toml

@@ -108,12 +108,13 @@ metric_recorder = ["neard/metric_recorder"]
 delay_detector = ["neard/delay_detector"]
 rosetta_rpc = ["neard/rosetta_rpc"]
 nightly_protocol = ["near-primitives/nightly_protocol", "near-jsonrpc/nightly_protocol"]
-nightly_protocol_features = ["nightly_protocol", "neard/nightly_protocol_features", "protocol_feature_evm", "protocol_feature_block_header_v3", "protocol_feature_alt_bn128", "protocol_feature_access_key_nonce_range"]
+nightly_protocol_features = ["nightly_protocol", "neard/nightly_protocol_features", "protocol_feature_evm", "protocol_feature_block_header_v3", "protocol_feature_alt_bn128", "protocol_feature_access_key_nonce_range", "protocol_feature_tx_size_limit"]
 protocol_feature_forward_chunk_parts = ["neard/protocol_feature_forward_chunk_parts"]
 protocol_feature_evm = ["neard/protocol_feature_evm", "testlib/protocol_feature_evm", "runtime-params-estimator/protocol_feature_evm"]
 protocol_feature_alt_bn128 = ["neard/protocol_feature_alt_bn128", "testlib/protocol_feature_alt_bn128", "runtime-params-estimator/protocol_feature_alt_bn128"]
 protocol_feature_block_header_v3 = ["near-primitives/protocol_feature_block_header_v3", "near-chain/protocol_feature_block_header_v3", "neard/protocol_feature_block_header_v3"]
 protocol_feature_access_key_nonce_range = ["neard/protocol_feature_access_key_nonce_range"]
+protocol_feature_tx_size_limit = ["near-primitives/protocol_feature_tx_size_limit", "node-runtime/protocol_feature_tx_size_limit", "neard/protocol_feature_tx_size_limit"]
 
 # enable this to build neard with wasmer 1.0 runner
 # now if none of wasmer0_default, wasmer1_default or wasmtime_default is enabled, wasmer0 would be default

chain/chain/src/validate.rs

@@ -83,7 +83,7 @@ pub fn validate_chunk_proofs(chunk: &ShardChunk, runtime_adapter: &dyn RuntimeAd
 }
 
 /// Validates that the given transactions are in proper valid order.
-/// See https://nomicon.io/BlockchainLayer/Transactions.html#transaction-ordering
+/// See https://nomicon.io/ChainSpec/Transactions.html#transaction-ordering
 pub fn validate_transactions_order(transactions: &[SignedTransaction]) -> bool {
     let mut nonces: HashMap<(&AccountId, &PublicKey), Nonce> = HashMap::new();
     let mut batches: HashMap<(&AccountId, &PublicKey), usize> = HashMap::new();

core/primitives-core/Cargo.toml

@@ -27,3 +27,4 @@ default = []
 costs_counting = []
 protocol_feature_evm = []
 protocol_feature_alt_bn128 = []
+protocol_feature_tx_size_limit = []

core/primitives-core/src/config.rs

@@ -21,6 +21,7 @@ pub struct VMConfig {
 
 /// Describes limits for VM and Runtime.
 #[derive(Debug, Serialize, Deserialize, Clone, Hash, PartialEq, Eq)]
+#[serde(default)]
 pub struct VMLimitConfig {
     /// Max amount of gas that can be used, excluding gas attached to promises.
     pub max_gas_burnt: Gas,
@@ -68,6 +69,9 @@ pub struct VMLimitConfig {
     pub max_length_returned_data: u64,
     /// Max contract size
     pub max_contract_size: u64,
+    /// Max transaction size
+    #[cfg(feature = "protocol_feature_tx_size_limit")]
+    pub max_transaction_size: u64,
     /// Max storage key size
     pub max_length_storage_key: u64,
     /// Max storage value size
@@ -149,6 +153,8 @@ impl Default for VMLimitConfig {
             max_arguments_length: 4 * 2u64.pow(20), // 4 Mib
             max_length_returned_data: 4 * 2u64.pow(20), // 4 Mib
             max_contract_size: 4 * 2u64.pow(20),    // 4 Mib,
+            #[cfg(feature = "protocol_feature_tx_size_limit")]
+            max_transaction_size: 4 * 2u64.pow(20), // 4 Mib
 
             max_length_storage_key: 4 * 2u64.pow(20), // 4 Mib
             max_length_storage_value: 4 * 2u64.pow(20), // 4 Mib

core/primitives/Cargo.toml

@@ -49,7 +49,9 @@ protocol_feature_evm = ["near-primitives-core/protocol_feature_evm"]
 protocol_feature_block_header_v3 = []
 protocol_feature_alt_bn128 = ["near-primitives-core/protocol_feature_alt_bn128", "near-vm-errors/protocol_feature_alt_bn128"]
 protocol_feature_access_key_nonce_range = []
-nightly_protocol_features = ["nightly_protocol", "protocol_feature_forward_chunk_parts", "protocol_feature_rectify_inflation", "protocol_feature_evm", "protocol_feature_block_header_v3", "protocol_feature_access_key_nonce_range", "protocol_feature_alt_bn128"]
+protocol_feature_tx_size_limit = ["near-primitives-core/protocol_feature_tx_size_limit"]
+
+nightly_protocol_features = ["nightly_protocol", "protocol_feature_forward_chunk_parts", "protocol_feature_rectify_inflation", "protocol_feature_evm", "protocol_feature_block_header_v3", "protocol_feature_access_key_nonce_range", "protocol_feature_alt_bn128", "protocol_feature_tx_size_limit"]
 nightly_protocol = []
 
 

core/primitives/src/errors.rs

@@ -143,6 +143,9 @@ pub enum InvalidTxError {
     Expired,
     /// An error occurred while validating actions of a Transaction.
     ActionsValidation(ActionsValidationError),
+    /// The size of serialized transaction exceeded the limit.
+    #[cfg(feature = "protocol_feature_tx_size_limit")]
+    TransactionSizeExceeded { size: u64, limit: u64 },
 }
 
 #[derive(
@@ -439,6 +442,12 @@ impl Display for InvalidTxError {
                 write!(f, "Transaction actions validation error: {}", error)
             }
             InvalidTxError::NonceTooLarge { tx_nonce, upper_bound } => { write!(f, "Transaction nonce {} must be smaller than the access key nonce upper bound {}", tx_nonce, upper_bound) }
+            #[cfg(feature = "protocol_feature_tx_size_limit")]
+            InvalidTxError::TransactionSizeExceeded { size, limit } => write!(
+                f,
+                "Size of serialized transaction {} exceeded the limit {}",
+                size, limit
+            ),
         }
     }
 }

core/primitives/src/version.rs

@@ -94,6 +94,8 @@ pub enum ProtocolFeature {
     AltBn128,
     #[cfg(feature = "protocol_feature_access_key_nonce_range")]
     AccessKeyNonceRange,
+    #[cfg(feature = "protocol_feature_tx_size_limit")]
+    TransactionSizeLimit,
 }
 
 /// Current latest stable version of the protocol.
@@ -102,7 +104,7 @@ pub const PROTOCOL_VERSION: ProtocolVersion = 42;
 
 /// Current latest nightly version of the protocol.
 #[cfg(feature = "nightly_protocol")]
-pub const PROTOCOL_VERSION: ProtocolVersion = 106;
+pub const PROTOCOL_VERSION: ProtocolVersion = 107;
 
 lazy_static! {
     static ref STABLE_PROTOCOL_FEATURES_TO_VERSION_MAPPING: HashMap<ProtocolFeature, ProtocolVersion> =
@@ -142,6 +144,8 @@ lazy_static! {
             (ProtocolFeature::AltBn128, 105),
             #[cfg(feature = "protocol_feature_access_key_nonce_range")]
             (ProtocolFeature::AccessKeyNonceRange, 106),
+            #[cfg(feature = "protocol_feature_tx_size_limit")]
+            (ProtocolFeature::TransactionSizeLimit, 107),
         ]
         .into_iter()
         .collect();

neard/Cargo.toml

@@ -72,7 +72,8 @@ protocol_feature_evm = ["near-primitives/protocol_feature_evm", "node-runtime/pr
 protocol_feature_alt_bn128 = ["near-primitives/protocol_feature_alt_bn128", "node-runtime/protocol_feature_alt_bn128"]
 protocol_feature_block_header_v3 = ["near-epoch-manager/protocol_feature_block_header_v3", "near-primitives/protocol_feature_block_header_v3", "near-chain/protocol_feature_block_header_v3", "near-client/protocol_feature_block_header_v3"]
 protocol_feature_access_key_nonce_range = ["near-primitives/protocol_feature_access_key_nonce_range", "node-runtime/protocol_feature_access_key_nonce_range", "near-client/protocol_feature_access_key_nonce_range"]
-nightly_protocol_features = ["nightly_protocol", "near-primitives/nightly_protocol_features", "near-client/nightly_protocol_features", "near-epoch-manager/nightly_protocol_features", "near-store/nightly_protocol_features", "protocol_feature_forward_chunk_parts", "protocol_feature_rectify_inflation", "protocol_feature_evm", "protocol_feature_block_header_v3", "protocol_feature_alt_bn128", "protocol_feature_access_key_nonce_range"]
+protocol_feature_tx_size_limit = ["near-primitives/protocol_feature_tx_size_limit", "node-runtime/protocol_feature_tx_size_limit"]
+nightly_protocol_features = ["nightly_protocol", "near-primitives/nightly_protocol_features", "near-client/nightly_protocol_features", "near-epoch-manager/nightly_protocol_features", "near-store/nightly_protocol_features", "protocol_feature_forward_chunk_parts", "protocol_feature_rectify_inflation", "protocol_feature_evm", "protocol_feature_block_header_v3", "protocol_feature_alt_bn128", "protocol_feature_access_key_nonce_range", "protocol_feature_tx_size_limit"]
 nightly_protocol = ["near-primitives/nightly_protocol", "near-jsonrpc/nightly_protocol"]
 
 [[bin]]

runtime/runtime/Cargo.toml

@@ -52,6 +52,7 @@ protocol_feature_alt_bn128 = [
     "near-vm-runner/protocol_feature_alt_bn128",
     "near-vm-errors/protocol_feature_alt_bn128",
 ]
+protocol_feature_tx_size_limit = []
 
 [dev-dependencies]
 tempfile = "3"

runtime/runtime/src/config.rs

@@ -60,6 +60,11 @@ pub fn safe_add_balance(a: Balance, b: Balance) -> Result<Balance, IntegerOverfl
     a.checked_add(b).ok_or_else(|| IntegerOverflowError {})
 }
 
+#[cfg(feature = "protocol_feature_tx_size_limit")]
+pub fn safe_add_usize(a: usize, b: usize) -> Result<usize, IntegerOverflowError> {
+    a.checked_add(b).ok_or_else(|| IntegerOverflowError {})
+}
+
 #[macro_export]
 macro_rules! safe_add_balance_apply {
     ($x: expr) => {$x};

runtime/runtime/src/verifier.rs

@@ -25,6 +25,8 @@ use crate::VerificationResult;
 use near_primitives::checked_feature;
 use near_primitives::runtime::config::RuntimeConfig;
 use near_primitives::types::BlockHeight;
+#[cfg(feature = "protocol_feature_tx_size_limit")]
+use borsh::ser::BorshSerialize;
 
 /// Validates the transaction without using the state. It allows any node to validate a
 /// transaction before forwarding it to the node that tracks the `signer_id` account.
@@ -55,6 +57,19 @@ pub fn validate_transaction(
         return Err(InvalidTxError::InvalidSignature.into());
     }
 
+    #[cfg(feature = "protocol_feature_tx_size_limit")]
+    {
+        let transaction_size = signed_transaction.try_to_vec()
+            .expect("Borsh serializer is not expected to ever fail").len() as u64;
+        let max_transaction_size = config.wasm_config.limit_config.max_transaction_size;
+        if transaction_size > max_transaction_size {
+            return Err(InvalidTxError::TransactionSizeExceeded {
+                size: transaction_size,
+                limit: max_transaction_size,
+            }.into());
+        }
+    }
+
     validate_actions(&config.wasm_config.limit_config, &transaction.actions)
         .map_err(|e| InvalidTxError::ActionsValidation(e))?;
 
@@ -1176,6 +1191,56 @@ mod tests {
         );
     }
 
+    #[test]
+    #[cfg(feature = "protocol_feature_tx_size_limit")]
+    fn test_validate_transaction_exceeding_tx_size_limit() {
+        let (signer, mut state_update, gas_price) = setup_common(
+            TESTING_INIT_BALANCE,
+            0,
+            Some(AccessKey {
+                nonce: 0,
+                permission: AccessKeyPermission::FunctionCall(FunctionCallPermission {
+                    allowance: None,
+                    receiver_id: bob_account(),
+                    method_names: vec!["not_hello".to_string(), "world".to_string()],
+                }),
+            }),
+        );
+
+        let transaction = SignedTransaction::from_actions(
+            1,
+            alice_account(),
+            bob_account(),
+            &*signer,
+            vec![Action::DeployContract(DeployContractAction {
+                code: vec![1; 5]
+            }),],
+            CryptoHash::default());
+        let transaction_size = transaction.try_to_vec()
+            .expect("Borsh serializer is not expected to ever fail").len() as u64;
+
+        let mut config = RuntimeConfig::default();
+        let max_transaction_size = transaction_size - 1;
+        config.wasm_config.limit_config.max_transaction_size = transaction_size - 1;
+
+        assert_eq!(
+            verify_and_charge_transaction(
+                &config,
+                &mut state_update,
+                gas_price,
+                &transaction,
+                true,
+                None,
+                PROTOCOL_VERSION,
+            )
+                .expect_err("expected an error"),
+            RuntimeError::InvalidTxError(InvalidTxError::TransactionSizeExceeded {
+                size: transaction_size,
+                limit: max_transaction_size
+            }),
+        );
+    }
+
     // Receipts
 
     #[test]

test-utils/testlib/Cargo.toml

@@ -54,3 +54,4 @@ protocol_feature_alt_bn128 = [
     "near-vm-errors/protocol_feature_alt_bn128",
 ]
 protocol_feature_evm = ["near-evm-runner/protocol_feature_evm", "near-primitives/protocol_feature_evm", "neard/protocol_feature_evm", "node-runtime/protocol_feature_evm", "near-chain-configs/protocol_feature_evm", "near-chain/protocol_feature_evm"]
+protocol_feature_tx_size_limit = ["near-primitives/protocol_feature_tx_size_limit", "node-runtime/protocol_feature_tx_size_limit"]