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/test_utils.rs

@@ -1,4 +1,8 @@
 use crate::account::{AccessKey, AccessKeyPermission, Account};
+use crate::action::{
+    DeployGlobalContractAction, GlobalContractDeployMode, GlobalContractIdentifier,
+    UseGlobalContractAction,
+};
 use crate::block::Block;
 use crate::block_body::{BlockBody, ChunkEndorsementSignatures};
 use crate::block_header::BlockHeader;
@@ -273,6 +277,52 @@ impl SignedTransaction {
         )
     }
 
+    pub fn deploy_global_contract(
+        nonce: Nonce,
+        contract_id: &AccountId,
+        code: Vec<u8>,
+        signer: &Signer,
+        block_hash: CryptoHash,
+        deploy_mode: GlobalContractDeployMode,
+    ) -> SignedTransaction {
+        let signer_id = contract_id.clone();
+        let receiver_id = contract_id.clone();
+        SignedTransaction::from_actions(
+            nonce,
+            signer_id,
+            receiver_id,
+            &signer,
+            vec![Action::DeployGlobalContract(DeployGlobalContractAction {
+                code: code.into(),
+                deploy_mode,
+            })],
+            block_hash,
+            0,
+        )
+    }
+
+    pub fn use_global_contract(
+        nonce: Nonce,
+        contract_id: &AccountId,
+        signer: &Signer,
+        block_hash: CryptoHash,
+        contract_identifier: GlobalContractIdentifier,
+    ) -> SignedTransaction {
+        let signer_id = contract_id.clone();
+        let receiver_id = contract_id.clone();
+        SignedTransaction::from_actions(
+            nonce,
+            signer_id,
+            receiver_id,
+            &signer,
+            vec![Action::UseGlobalContract(Box::new(UseGlobalContractAction {
+                contract_identifier,
+            }))],
+            block_hash,
+            0,
+        )
+    }
+
     pub fn create_contract(
         nonce: Nonce,
         originator: AccountId,

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,16 @@ 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() {
-            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

@@ -4,6 +4,8 @@ use near_chain_configs::test_genesis::{
     build_genesis_and_epoch_config_store, GenesisAndEpochConfigParams, ValidatorsSpec,
 };
 use near_o11y::testonly::init_test_logger;
+use near_primitives::action::{GlobalContractDeployMode, GlobalContractIdentifier};
+use near_primitives::hash::CryptoHash;
 use near_primitives::shard_layout::ShardLayout;
 use near_primitives::types::AccountId;
 use near_primitives::version::PROTOCOL_VERSION;
@@ -19,6 +21,7 @@ use crate::test_loop::utils::get_head_height;
 use crate::test_loop::utils::transactions::{
     call_contract, check_txs, deploy_contract, make_accounts,
 };
+use crate::test_loop::utils::transactions::{deploy_global_contract, use_global_contract};
 
 const EPOCH_LENGTH: u64 = 10;
 const GENESIS_HEIGHT: u64 = 1000;
@@ -74,6 +77,93 @@ fn test_contract_distribution_cross_shard() {
     env.shutdown_and_drain_remaining_events(Duration::seconds(20));
 }
 
+#[cfg_attr(not(feature = "nightly_protocol"), ignore)]
+#[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);
+}
+
+#[cfg_attr(not(feature = "nightly_protocol"), ignore)]
+#[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,7 @@ use near_client::test_utils::test_loop::ClientQueries;
 use near_client::{Client, ProcessTxResponse};
 use near_crypto::Signer;
 use near_network::client::ProcessTxRequest;
+use near_primitives::action::{GlobalContractDeployMode, GlobalContractIdentifier};
 use near_primitives::block::Tip;
 use near_primitives::errors::InvalidTxError;
 use near_primitives::hash::CryptoHash;
@@ -303,6 +304,56 @@ pub fn deploy_contract(
     tx_hash
 }
 
+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::deploy_global_contract(
+        nonce,
+        account_id,
+        code,
+        &signer,
+        block_hash,
+        deploy_mode,
+    );
+    let tx_hash = tx.get_hash();
+    submit_tx(node_datas, rpc_id, tx);
+
+    tx_hash
+}
+
+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::use_global_contract(
+        nonce,
+        account_id,
+        &signer,
+        block_hash,
+        global_contract_identifier,
+    );
+    let tx_hash = tx.get_hash();
+    submit_tx(node_datas, rpc_id, tx);
+
+    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