specify deposit limit for nested instantiate

save: works with test

cleaned up debugging outputs

frame/contracts/fixtures/caller_contract.wat

@@ -3,7 +3,7 @@
 	(import "seal0" "seal_balance" (func $seal_balance (param i32 i32)))
 	(import "seal2" "call" (func $seal_call (param i32 i32 i64 i64 i32 i32 i32 i32 i32 i32) (result i32)))
 	(import "seal2" "instantiate" (func $seal_instantiate
-		(param i32 i64 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+		(param i32 i64 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
 	))
 	(import "env" "memory" (memory 1 1))
 
@@ -45,6 +45,7 @@
 				(i32.const 24)	;; Pointer to the code hash.
 				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
 				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
 				(i32.const 0)	;; Pointer to the buffer with value to transfer
 				(i32.const 9)	;; Pointer to input data buffer address
 				(i32.const 7)	;; Length of input data buffer
@@ -68,6 +69,7 @@
 				(i32.const 24)	;; Pointer to the code hash.
 				(i64.const 1)	;; Supply too little ref_time weight
 				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
 				(i32.const 0)	;; Pointer to the buffer with value to transfer
 				(i32.const 8)	;; Pointer to input data buffer address
 				(i32.const 8)	;; Length of input data buffer
@@ -92,6 +94,7 @@
 				(i32.const 24)	;; Pointer to the code hash.
 				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
 				(i64.const 1)	;; Supply too little proof_size weight
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
 				(i32.const 0)	;; Pointer to the buffer with value to transfer
 				(i32.const 8)	;; Pointer to input data buffer address
 				(i32.const 8)	;; Length of input data buffer
@@ -122,6 +125,7 @@
 				(i32.const 24)	;; Pointer to the code hash.
 				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
 				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
 				(i32.const 0)	;; Pointer to the buffer with value to transfer
 				(i32.const 8)	;; Pointer to input data buffer address
 				(i32.const 8)	;; Length of input data buffer

frame/contracts/fixtures/create_storage_and_call.wat

@@ -21,7 +21,7 @@
         (i32.store (i32.const 0) (i32.const 512))
 
         ;; copy input at address 4:
-		;; first 4 bytes for the storage size
+		;; first 4 bytes for the size of the storage to be created in callee
 		;; next 32 bytes are for the callee address
 		;; next bytes for the encoded deposit limit
         (call $seal_input (i32.const 4) (i32.const 0))
@@ -40,7 +40,7 @@
 				(i32.const 8)  ;; Pointer to "callee" address
 				(i64.const 0)  ;; How much ref_time to devote for the execution. 0 = all
 				(i64.const 0)  ;; How much proof_limit to devote for the execution. 0 = all
-				(i32.const 40) ;; Pointer to storage deposit limit
+				(i32.const 40) ;; Pointer to the storage deposit limit
 				(i32.const 512) ;; Pointer to the buffer with value to transfer
 				(i32.const 4) ;; Pointer to input data buffer address
 				(i32.const 4)  ;; Length of input data buffer

frame/contracts/src/exec.rs

@@ -150,6 +150,7 @@ pub trait Ext: sealing::Sealed {
 	fn instantiate(
 		&mut self,
 		gas_limit: Weight,
+		deposit_limit: BalanceOf<Self::T>,
 		code: CodeHash<Self::T>,
 		value: BalanceOf<Self::T>,
 		input_data: Vec<u8>,
@@ -895,6 +896,13 @@ where
 						return Err(Error::<T>::TerminatedInConstructor.into())
 					}
 
+					// If a special limit was set for the sub-call, we enforce it here.
+					// This is needed because contract constructor might write to storage.
+					// The sub-call will be rolled back in case the limit is exhausted.
+					let frame = self.top_frame_mut();
+					let contract = frame.contract_info.as_contract();
+					frame.nested_storage.enforce_subcall_limit(contract)?;
+
 					// Deposit an instantiation event.
 					Contracts::<T>::deposit_event(
 						vec![T::Hashing::hash_of(self.caller()), T::Hashing::hash_of(account_id)],
@@ -1200,6 +1208,7 @@ where
 	fn instantiate(
 		&mut self,
 		gas_limit: Weight,
+		deposit_limit: BalanceOf<Self::T>,
 		code_hash: CodeHash<T>,
 		value: BalanceOf<T>,
 		input_data: Vec<u8>,
@@ -1217,7 +1226,7 @@ where
 			},
 			value,
 			gas_limit,
-			BalanceOf::<T>::zero(),
+			deposit_limit,
 		)?;
 		let account_id = self.top_frame().account_id.clone();
 		self.run(executable, input_data).map(|ret| (account_id, ret))
@@ -2339,6 +2348,7 @@ mod tests {
 					.ext
 					.instantiate(
 						Weight::zero(),
+						BalanceOf::<Test>::zero(),
 						dummy_ch,
 						<Test as Config>::Currency::minimum_balance(),
 						vec![],
@@ -2403,6 +2413,7 @@ mod tests {
 				assert_matches!(
 					ctx.ext.instantiate(
 						Weight::zero(),
+						BalanceOf::<Test>::zero(),
 						dummy_ch,
 						<Test as Config>::Currency::minimum_balance(),
 						vec![],
@@ -2927,6 +2938,7 @@ mod tests {
 			ctx.ext
 				.instantiate(
 					Weight::zero(),
+					BalanceOf::<Test>::zero(),
 					fail_code,
 					ctx.ext.minimum_balance() * 100,
 					vec![],
@@ -2940,6 +2952,7 @@ mod tests {
 				.ext
 				.instantiate(
 					Weight::zero(),
+					BalanceOf::<Test>::zero(),
 					success_code,
 					ctx.ext.minimum_balance() * 100,
 					vec![],
@@ -3454,15 +3467,31 @@ mod tests {
 			assert_eq!(ctx.ext.nonce(), 1);
 			// Should not change with a failed instantiation
 			assert_err!(
-				ctx.ext.instantiate(Weight::zero(), fail_code, 0, vec![], &[],),
+				ctx.ext.instantiate(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					fail_code,
+					0,
+					vec![],
+					&[],
+				),
 				ExecError {
 					error: <Error<Test>>::ContractTrapped.into(),
 					origin: ErrorOrigin::Callee
 				}
 			);
 			assert_eq!(ctx.ext.nonce(), 1);
 			// Successful instantation increments
-			ctx.ext.instantiate(Weight::zero(), success_code, 0, vec![], &[]).unwrap();
+			ctx.ext
+				.instantiate(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					success_code,
+					0,
+					vec![],
+					&[],
+				)
+				.unwrap();
 			assert_eq!(ctx.ext.nonce(), 2);
 			exec_success()
 		});

frame/contracts/src/storage/meter.rs

@@ -420,7 +420,7 @@ where
 		self.total_deposit = deposit.clone();
 		info.storage_base_deposit = deposit.charge_or_zero();
 
-		// Usually, deposit charges are deferred to be able to coalesce them with refunds.
+		// Normally, deposit charges are deferred to be able to coalesce them with refunds.
 		// However, we need to charge immediately so that the account is created before
 		// charges possibly below the ed are collected and fail.
 		E::charge(