feat: global contract usage

chain/chain-primitives/src/error.rs

@@ -1,6 +1,6 @@
 use near_primitives::block::BlockValidityError;
 use near_primitives::challenge::{ChunkProofs, ChunkState, MaybeEncodedShardChunk};
-use near_primitives::errors::{ChunkAccessError, EpochError, StorageError};
+use near_primitives::errors::{ChunkAccessError, EpochError, GlobalContractError, StorageError};
 use near_primitives::shard_layout::ShardLayoutError;
 use near_primitives::sharding::{BadHeaderForProtocolVersionError, ChunkHash, ShardChunkHeader};
 use near_primitives::types::{BlockHeight, EpochId, ShardId, ShardIndex};
@@ -251,6 +251,9 @@ pub enum Error {
     /// Invalid chunk header version for protocol version
     #[error(transparent)]
     BadHeaderForProtocolVersion(#[from] BadHeaderForProtocolVersionError),
+    /// Global contract error.
+    #[error("Global Contract Error: {0}")]
+    GlobalContractError(GlobalContractError),
     /// Anything else
     #[error("Other Error: {0}")]
     Other(String),
@@ -289,6 +292,7 @@ impl Error {
             | Error::StorageError(_)
             | Error::GCError(_)
             | Error::ReshardingError(_)
+            | Error::GlobalContractError(_)
             | Error::DBNotFoundErr(_) => false,
             Error::InvalidBlockPastTime(_, _)
             | Error::InvalidBlockFutureTime(_)
@@ -424,6 +428,7 @@ impl Error {
             Error::NotAChunkValidator => "not_a_chunk_validator",
             Error::InvalidChallengeRoot => "invalid_challenge_root",
             Error::ReshardingError(_) => "resharding_error",
+            Error::GlobalContractError(_) => "global_contract_error",
             Error::BadHeaderForProtocolVersion(_) => "bad_header_for_protocol_version",
         }
     }

chain/chain/src/runtime/mod.rs

@@ -336,6 +336,7 @@ impl NightshadeRuntime {
                 // TODO(#2152): process gracefully
                 RuntimeError::ReceiptValidationError(e) => panic!("{}", e),
                 RuntimeError::ValidatorError(e) => e.into(),
+                RuntimeError::GlobalContractError(e) => Error::GlobalContractError(e),
             })?;
         let elapsed = instant.elapsed();
 

core/primitives/src/errors.rs

@@ -1,3 +1,4 @@
+use crate::action::GlobalContractIdentifier;
 use crate::hash::CryptoHash;
 use crate::serialize::dec_format;
 use crate::shard_layout::ShardLayoutError;
@@ -67,6 +68,8 @@ pub enum RuntimeError {
     ReceiptValidationError(ReceiptValidationError),
     /// Error when accessing validator information. Happens inside epoch manager.
     ValidatorError(EpochError),
+    /// Global contract errors.
+    GlobalContractError(GlobalContractError),
 }
 
 impl std::fmt::Display for RuntimeError {
@@ -935,6 +938,18 @@ impl Display for ActionErrorKind {
     }
 }
 
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub enum GlobalContractError {
+    IdentifierNotFound(GlobalContractIdentifier),
+}
+
+impl Display for GlobalContractError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let Self::IdentifierNotFound(id) = self;
+        write!(f, "GlobalContractError: {:?}", id)
+    }
+}
+
 #[derive(Eq, PartialEq, Clone)]
 pub enum EpochError {
     /// Error calculating threshold from given stakes for given number of seats.

core/primitives/src/trie_key.rs

@@ -1,5 +1,5 @@
-use crate::hash::CryptoHash;
 use crate::types::AccountId;
+use crate::{action::GlobalContractIdentifier, hash::CryptoHash};
 use borsh::{to_vec, BorshDeserialize, BorshSerialize};
 use near_crypto::PublicKey;
 use near_primitives_core::types::ShardId;
@@ -124,6 +124,19 @@ impl GlobalContractCodeIdentifier {
     }
 }
 
+impl From<GlobalContractIdentifier> for GlobalContractCodeIdentifier {
+    fn from(identifier: GlobalContractIdentifier) -> Self {
+        match identifier {
+            GlobalContractIdentifier::CodeHash(hash) => {
+                GlobalContractCodeIdentifier::CodeHash(hash)
+            }
+            GlobalContractIdentifier::AccountId(account_id) => {
+                GlobalContractCodeIdentifier::AccountId(account_id)
+            }
+        }
+    }
+}
+
 /// Describes the key of a specific key-value record in a state trie.
 #[derive(Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize, ProtocolSchema)]
 pub enum TrieKey {

core/store/src/trie/update.rs

@@ -5,10 +5,11 @@ use crate::contract::ContractStorage;
 use crate::trie::TrieAccess;
 use crate::trie::{KeyLookupMode, TrieChanges};
 use crate::StorageError;
+use near_primitives::account::AccountContract;
 use near_primitives::apply::ApplyChunkReason;
 use near_primitives::hash::{hash, CryptoHash};
 use near_primitives::stateless_validation::contract_distribution::ContractUpdates;
-use near_primitives::trie_key::TrieKey;
+use near_primitives::trie_key::{GlobalContractCodeIdentifier, TrieKey};
 use near_primitives::types::{
     AccountId, RawStateChange, RawStateChanges, RawStateChangesWithTrieKey, StateChangeCause,
     StateRoot, TrieCacheMode,
@@ -339,6 +340,7 @@ impl TrieUpdate {
         &self,
         account_id: AccountId,
         code_hash: CryptoHash,
+        account_contract: &AccountContract,
         apply_reason: ApplyChunkReason,
         protocol_version: ProtocolVersion,
     ) -> Result<(), StorageError> {
@@ -357,10 +359,19 @@ impl TrieUpdate {
         // Only record the call if trie contains the contract (with the given hash) being called deployed to the given account.
         // This avoids recording contracts that do not exist or are newly-deployed to the account.
         // Note that the check below to see if the contract exists has no side effects (not charging gas or recording trie nodes)
-        if code_hash == CryptoHash::default() {
+        if account_contract.is_none() {
             return Ok(());
         }
-        let trie_key = TrieKey::ContractCode { account_id };
+        let trie_key = match account_contract {
+            AccountContract::None => return Ok(()),
+            AccountContract::Local(_) => TrieKey::ContractCode { account_id },
+            AccountContract::Global(code_hash) => TrieKey::GlobalContractCode {
+                identifier: GlobalContractCodeIdentifier::CodeHash(*code_hash),
+            },
+            AccountContract::GlobalByAccount(account_id) => TrieKey::GlobalContractCode {
+                identifier: GlobalContractCodeIdentifier::AccountId(account_id.clone()),
+            },
+        };
         let contract_ref = self
             .trie
             .get_optimized_ref_no_side_effects(&trie_key.to_vec(), KeyLookupMode::FlatStorage)

integration-tests/src/test_loop/tests/contract_distribution_cross_shard.rs

@@ -74,6 +74,99 @@ fn test_contract_distribution_cross_shard() {
     env.shutdown_and_drain_remaining_events(Duration::seconds(20));
 }
 
+#[cfg(feature = "nightly_protocol")]
+mod global_contracts_tests {
+    use super::*;
+    use crate::test_loop::utils::transactions::{deploy_global_contract, use_global_contract};
+    use near_primitives::action::{GlobalContractDeployMode, GlobalContractIdentifier};
+    use near_primitives::hash::CryptoHash;
+
+    #[test]
+    fn test_global_contract_by_hash() {
+        let (env, accounts, contract, rpc_id) = setup_global_contract_test();
+        let deploy_mode = GlobalContractDeployMode::CodeHash;
+        test_global_contract(env, deploy_mode, accounts.as_slice(), &contract, rpc_id);
+    }
+
+    #[test]
+    fn test_global_contract_by_account_id() {
+        let (env, accounts, contract, rpc_id) = setup_global_contract_test();
+        let deploy_mode = GlobalContractDeployMode::AccountId;
+        test_global_contract(env, deploy_mode, accounts.as_slice(), &contract, rpc_id);
+    }
+
+    fn setup_global_contract_test() -> (TestLoopEnv, Vec<AccountId>, ContractCode, AccountId) {
+        init_test_logger();
+        let accounts = make_accounts(NUM_ACCOUNTS);
+
+        let (env, rpc_id) = setup(&accounts);
+
+        let rpc_index = 8;
+        assert_eq!(accounts[rpc_index], rpc_id);
+
+        let contract = ContractCode::new(near_test_contracts::rs_contract().to_vec(), None);
+        (env, accounts, contract, rpc_id)
+    }
+
+    fn test_global_contract(
+        mut env: TestLoopEnv,
+        deploy_mode: GlobalContractDeployMode,
+        accounts: &[AccountId],
+        contract: &ContractCode,
+        rpc_id: AccountId,
+    ) {
+        let mut nonce = 1;
+        let deploy_tx = deploy_global_contract(
+            &mut env.test_loop,
+            &env.datas,
+            &rpc_id,
+            &accounts[0],
+            contract.code().into(),
+            deploy_mode.clone(),
+            nonce,
+        );
+        nonce += 1;
+        env.test_loop.run_for(Duration::seconds(3));
+        check_txs(&env.test_loop.data, &env.datas, &rpc_id, &[deploy_tx]);
+        let identifier = match deploy_mode {
+            GlobalContractDeployMode::CodeHash => {
+                let code_hash = CryptoHash::hash_bytes(contract.code());
+                GlobalContractIdentifier::CodeHash(code_hash)
+            }
+            GlobalContractDeployMode::AccountId => {
+                GlobalContractIdentifier::AccountId(accounts[0].clone())
+            }
+        };
+        // test on accounts from different shards
+        for account in [&accounts[1], &accounts[6]] {
+            let use_tx = use_global_contract(
+                &mut env.test_loop,
+                &env.datas,
+                &rpc_id,
+                account,
+                identifier.clone(),
+                nonce,
+            );
+            nonce += 1;
+            env.test_loop.run_for(Duration::seconds(3));
+            check_txs(&env.test_loop.data, &env.datas, &rpc_id, &[use_tx]);
+            let call_tx = call_contract(
+                &mut env.test_loop,
+                &env.datas,
+                &rpc_id,
+                account,
+                account,
+                "log_something".to_owned(),
+                vec![],
+                nonce,
+            );
+            env.test_loop.run_for(Duration::seconds(3));
+            check_txs(&env.test_loop.data, &env.datas, &rpc_id, &[call_tx]);
+        }
+        env.shutdown_and_drain_remaining_events(Duration::seconds(20));
+    }
+}
+
 fn setup(accounts: &Vec<AccountId>) -> (TestLoopEnv, AccountId) {
     let builder = TestLoopBuilder::new();
 

integration-tests/src/test_loop/utils/transactions.rs

@@ -13,6 +13,11 @@ use near_client::test_utils::test_loop::ClientQueries;
 use near_client::{Client, ProcessTxResponse};
 use near_crypto::Signer;
 use near_network::client::ProcessTxRequest;
+#[cfg(feature = "nightly_protocol")]
+use near_primitives::action::{
+    Action, DeployGlobalContractAction, GlobalContractDeployMode, GlobalContractIdentifier,
+    UseGlobalContractAction,
+};
 use near_primitives::block::Tip;
 use near_primitives::errors::InvalidTxError;
 use near_primitives::hash::CryptoHash;
@@ -303,6 +308,67 @@ pub fn deploy_contract(
     tx_hash
 }
 
+#[cfg(feature = "nightly_protocol")]
+pub fn deploy_global_contract(
+    test_loop: &mut TestLoopV2,
+    node_datas: &[TestData],
+    rpc_id: &AccountId,
+    account_id: &AccountId,
+    code: Vec<u8>,
+    deploy_mode: GlobalContractDeployMode,
+    nonce: u64,
+) -> CryptoHash {
+    let block_hash = get_shared_block_hash(node_datas, &test_loop.data);
+    let signer = create_user_test_signer(&account_id);
+
+    let tx = SignedTransaction::from_actions(
+        nonce,
+        account_id.clone(),
+        account_id.clone(),
+        &signer,
+        vec![Action::DeployGlobalContract(DeployGlobalContractAction {
+            code: code.into(),
+            deploy_mode,
+        })],
+        block_hash,
+        0,
+    );
+    let tx_hash = tx.get_hash();
+    submit_tx(node_datas, rpc_id, tx);
+
+    tx_hash
+}
+
+#[cfg(feature = "nightly_protocol")]
+pub fn use_global_contract(
+    test_loop: &mut TestLoopV2,
+    node_datas: &[TestData],
+    rpc_id: &AccountId,
+    account_id: &AccountId,
+    global_contract_identifier: GlobalContractIdentifier,
+    nonce: u64,
+) -> CryptoHash {
+    let block_hash = get_shared_block_hash(node_datas, &test_loop.data);
+    let signer = create_user_test_signer(&account_id);
+
+    let tx = SignedTransaction::from_actions(
+        nonce,
+        account_id.clone(),
+        account_id.clone(),
+        &signer,
+        vec![Action::UseGlobalContract(Box::new(UseGlobalContractAction {
+            contract_identifier: global_contract_identifier,
+        }))],
+        block_hash,
+        0,
+    );
+    let tx_hash = tx.get_hash();
+    submit_tx(node_datas, rpc_id, tx);
+
+    tracing::debug!(target: "test", ?account_id, ?tx_hash, "used global contract");
+    tx_hash
+}
+
 /// Call the contract deployed at contract id from the sender id.
 ///
 /// This function does not wait until the transactions is executed.

integration-tests/src/user/runtime_user.rs

@@ -130,6 +130,7 @@ impl RuntimeUser {
                     }
                     RuntimeError::ReceiptValidationError(e) => panic!("{}", e),
                     RuntimeError::ValidatorError(e) => panic!("{}", e),
+                    RuntimeError::GlobalContractError(e) => panic!("{}", e),
                 })?;
             for outcome_with_id in apply_result.outcomes {
                 self.transaction_results