feat: Implicit account creation (#3251)

This PR implements near/NEPs#71

It contains a bunch of boilerplate code to pass the protocol version to VM and tests.

Logical changes:
- Bumps protocol version to 35
- Post protocol version, when a transfer action is executed on the 64-length hex like account ID as a single action in a transaction, it creates a new account if the account doesn't exist and add the ED25519 public key from the account ID hex representation.
- If a CreateAccount action attempts to create 64-length hex like account, it fails.
- Refunds don't automatically create accounts, because refunds are free and we don't want some type of abuse. NOTE: Account deletion with beneficiary creates a refund, so it'll not create a new account.
- `TransferAction` fee cost on such 64-len hex accounts include `CreateAction` and `AddFullAccessKey` costs
- The fee is also updated when calling a promise.
- `VMLogic::new` change is backward compatible until we release a new `near-sdk` version. So it shouldn't break master after pushing it.
- Bump `near-vm-*` versions to `2.2.0`.

TODO:

- [x] Add integration test for transfer from promise
- [x] Add migration test for transfer to 64len
- [x] Uncomment `VMLogic::new` for `near-sdk` `MockedBlockchain`

## Test plan:
- CI
- Added integration test and migration test

chain/chain/src/test_utils.rs

@@ -462,6 +462,7 @@ impl RuntimeAdapter for KeyValueRuntime {
  _state_update: Option<StateRoot>,
  _transaction: &SignedTransaction,
  _verify_signature: bool,
+ _current_protocol_version: ProtocolVersion,
  ) -> Result<Option<InvalidTxError>, Error> {
  Ok(None)
  }
@@ -474,6 +475,7 @@ impl RuntimeAdapter for KeyValueRuntime {
  _state_root: StateRoot,
  transactions: &mut dyn PoolIterator,
  _chain_validate: &mut dyn FnMut(&SignedTransaction) -> bool,
+ _current_protocol_version: ProtocolVersion,
  ) -> Result<Vec<SignedTransaction>, Error> {
  let mut res = vec![];
  while let Some(iter) = transactions.next() {

chain/chain/src/types.rs

@@ -255,6 +255,7 @@ pub trait RuntimeAdapter: Send + Sync {
  state_root: Option<StateRoot>,
  transaction: &SignedTransaction,
  verify_signature: bool,
+ current_protocol_version: ProtocolVersion,
  ) -> Result<Option<InvalidTxError>, Error>;
 
  /// Returns an ordered list of valid transactions from the pool up the given limits.
@@ -272,6 +273,7 @@ pub trait RuntimeAdapter: Send + Sync {
  state_root: StateRoot,
  pool_iterator: &mut dyn PoolIterator,
  chain_validate: &mut dyn FnMut(&SignedTransaction) -> bool,
+ current_protocol_version: ProtocolVersion,
  ) -> Result<Vec<SignedTransaction>, Error>;
 
  /// Verify validator signature for the given epoch.

chain/client/src/client.rs

@@ -492,7 +492,7 @@ impl Client {
  .clone();
 
  let prev_block_header = self.chain.get_block_header(&prev_block_hash)?.clone();
- let transactions = self.prepare_transactions(shard_id, &chunk_extra, &prev_block_header);
+ let transactions = self.prepare_transactions(shard_id, &chunk_extra, &prev_block_header)?;
  let num_filtered_transactions = transactions.len();
  let (tx_root, _) = merklize(&transactions);
  let ReceiptResponse(_, outgoing_receipts) = self.chain.get_outgoing_receipts_for_shard(
@@ -556,36 +556,40 @@ impl Client {
  shard_id: ShardId,
  chunk_extra: &ChunkExtra,
  prev_block_header: &BlockHeader,
- ) -> Vec<SignedTransaction> {
+ ) -> Result<Vec<SignedTransaction>, Error> {
  let Self { chain, shards_mgr, runtime_adapter, .. } = self;
+
+ let next_epoch_id =
+ runtime_adapter.get_epoch_id_from_prev_block(&prev_block_header.hash())?;
+ let protocol_version = runtime_adapter.get_epoch_protocol_version(&next_epoch_id)?;
+
  let transactions = if let Some(mut iter) = shards_mgr.get_pool_iterator(shard_id) {
  let transaction_validity_period = chain.transaction_validity_period;
- runtime_adapter
- .prepare_transactions(
- prev_block_header.gas_price(),
- chunk_extra.gas_limit,
- shard_id,
- chunk_extra.state_root.clone(),
- &mut iter,
- &mut |tx: &SignedTransaction| -> bool {
- chain
- .mut_store()
- .check_transaction_validity_period(
- &prev_block_header,
- &tx.transaction.block_hash,
- transaction_validity_period,
- )
- .is_ok()
- },
- )
- .expect("no StorageError please")
+ runtime_adapter.prepare_transactions(
+ prev_block_header.gas_price(),
+ chunk_extra.gas_limit,
+ shard_id,
+ chunk_extra.state_root.clone(),
+ &mut iter,
+ &mut |tx: &SignedTransaction| -> bool {
+ chain
+ .mut_store()
+ .check_transaction_validity_period(
+ &prev_block_header,
+ &tx.transaction.block_hash,
+ transaction_validity_period,
+ )
+ .is_ok()
+ },
+ protocol_version,
+ )?
  } else {
  vec![]
  };
  // Reintroduce valid transactions back to the pool. They will be removed when the chunk is
  // included into the block.
  shards_mgr.reintroduce_transactions(shard_id, &transactions);
- transactions
+ Ok(transactions)
  }
 
  pub fn send_challenges(&mut self, challenges: Arc<RwLock<Vec<ChallengeBody>>>) {
@@ -1225,8 +1229,12 @@ impl Client {
  let gas_price = cur_block_header.gas_price();
  let epoch_id = self.runtime_adapter.get_epoch_id_from_prev_block(&head.last_block_hash)?;
 
- if let Some(err) =
- self.runtime_adapter.validate_tx(gas_price, None, &tx, true).expect("no storage errors")
+ let protocol_version = self.runtime_adapter.get_epoch_protocol_version(&epoch_id)?;
+
+ if let Some(err) = self
+ .runtime_adapter
+ .validate_tx(gas_price, None, &tx, true, protocol_version)
+ .expect("no storage errors")
  {
  debug!(target: "client", "Invalid tx during basic validation: {:?}", err);
  return Ok(NetworkClientResponses::InvalidTx(err));
@@ -1252,7 +1260,7 @@ impl Client {
  };
  if let Some(err) = self
  .runtime_adapter
- .validate_tx(gas_price, Some(state_root), &tx, false)
+ .validate_tx(gas_price, Some(state_root), &tx, false, protocol_version)
  .expect("no storage errors")
  {
  debug!(target: "client", "Invalid tx: {:?}", err);

chain/jsonrpc/res/rpc_errors_schema.json

@@ -452,7 +452,8 @@
  "TriesToStake",
  "InsufficientStake",
  "FunctionCallError",
- "NewReceiptValidationError"
+ "NewReceiptValidationError",
+ "OnlyImplicitAccountCreationAllowed"
  ],
  "props": {
  "index": ""
@@ -718,6 +719,13 @@
  "signer_id": ""
  }
  },
+ "OnlyImplicitAccountCreationAllowed": {
+ "name": "OnlyImplicitAccountCreationAllowed",
+ "subtypes": [],
+ "props": {
+ "account_id": ""
+ }
+ },
  "ReceiptValidationError": {
  "name": "ReceiptValidationError",
  "subtypes": [

core/crypto/src/test_utils.rs

@@ -7,7 +7,7 @@ use crate::{InMemorySigner, Signature};
 
 fn ed25519_key_pair_from_seed(seed: &str) -> ed25519_dalek::Keypair {
  let seed_bytes = seed.as_bytes();
- let len = seed_bytes.len();
+ let len = std::cmp::min(ed25519_dalek::SECRET_KEY_LENGTH, seed_bytes.len());
  let mut seed: [u8; ed25519_dalek::SECRET_KEY_LENGTH] = [b' '; ed25519_dalek::SECRET_KEY_LENGTH];
  seed[..len].copy_from_slice(&seed_bytes[..len]);
  let secret = ed25519_dalek::SecretKey::from_bytes(&seed).unwrap();
@@ -17,7 +17,7 @@ fn ed25519_key_pair_from_seed(seed: &str) -> ed25519_dalek::Keypair {
 
 fn secp256k1_secret_key_from_seed(seed: &str) -> secp256k1::key::SecretKey {
  let seed_bytes = seed.as_bytes();
- let len = seed_bytes.len();
+ let len = std::cmp::min(32, seed_bytes.len());
  let mut seed: [u8; 32] = [b' '; 32];
  seed[..len].copy_from_slice(&seed_bytes[..len]);
  let mut rng: StdRng = rand::SeedableRng::from_seed(seed);

core/primitives/src/errors.rs

@@ -384,6 +384,9 @@ pub enum ActionErrorKind {
  /// Error occurs when a new `ActionReceipt` created by the `FunctionCall` action fails
  /// receipt validation.
  NewReceiptValidationError(ReceiptValidationError),
+ /// Error occurs when a `CreateAccount` action is called on hex-characters account of length 64.
+ /// See implicit account creation NEP: https://github.com/nearprotocol/NEPs/pull/71
+ OnlyImplicitAccountCreationAllowed { account_id: AccountId },
 }
 
 impl From<ActionErrorKind> for ActionError {
@@ -670,7 +673,8 @@ impl Display for ActionErrorKind {
  ActionErrorKind::NewReceiptValidationError(e) => {
  write!(f, "An new action receipt created during a FunctionCall is not valid: {}", e)
  }
- ActionErrorKind::InsufficientStake { account_id, stake, minimum_stake } => write!(f, "Account {} tries to stake {} but minimum required stake is {}", account_id, stake, minimum_stake)
+ ActionErrorKind::InsufficientStake { account_id, stake, minimum_stake } => write!(f, "Account {} tries to stake {} but minimum required stake is {}", account_id, stake, minimum_stake),
+ ActionErrorKind::OnlyImplicitAccountCreationAllowed { account_id } => write!(f, "CreateAccount action is called on hex-characters account of length 64 {}", account_id)
  }
  }
 }

core/primitives/src/version.rs

@@ -18,7 +18,7 @@ pub const DB_VERSION: DbVersion = 8;
 pub type ProtocolVersion = u32;
 
 /// Current latest version of the protocol.
-pub const PROTOCOL_VERSION: ProtocolVersion = 34;
+pub const PROTOCOL_VERSION: ProtocolVersion = 35;
 /// Oldest supported version by this client.
 pub const OLDEST_BACKWARD_COMPATIBLE_PROTOCOL_VERSION: ProtocolVersion = 29;
 
@@ -31,3 +31,6 @@ pub const MIN_GAS_PRICE_NEP_92_FIX: Balance = 100_000_000;
 pub const MIN_PROTOCOL_VERSION_NEP_92_FIX: ProtocolVersion = 32;
 
 pub const CORRECT_RANDOM_VALUE_PROTOCOL_VERSION: ProtocolVersion = 33;
+
+/// See [NEP 71](https://github.com/nearprotocol/NEPs/pull/71)
+pub const IMPLICIT_ACCOUNT_CREATION_PROTOCOL_VERSION: ProtocolVersion = 35;

neard/res/genesis_config.json

@@ -1,5 +1,5 @@
 {
- "protocol_version": 34,
+ "protocol_version": 35,
  "genesis_time": "1970-01-01T00:00:00.000000000Z",
  "chain_id": "sample",
  "genesis_height": 0,
@@ -236,4 +236,4 @@
  "fishermen_threshold": "10000000000000000000000000",
  "minimum_stake_divisor": 10,
  "records": []
-}
+}