Add near-primitives-light instead of an near-primitives

.github/workflows/ci.yml

@@ -113,4 +113,4 @@ jobs:
           (cd near-smartcontracts && docker compose -f docker-compose.yml -f docker-compose.tests.yml up -d --no-build)
       - uses: actions/checkout@v3
       - name: Run tests for [web]
-        run: docker compose up
+        run: docker compose up --abort-on-container-exit

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "rust-analyzer.cargo.target": "wasm32-unknown-unknown"
-}

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["web-client", "near-rpc", "common-api"]
+members = ["web-client", "near-rpc", "common-api", "near-primitives-light"]
 
 [profile.release]
 codegen-units = 1

near-primitives-light/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "near-primitives-light"
+version = "0.1.0"
+edition = "2021"
+authors = ["silvestr@relayz.io"]
+description = """
+Copy-paste from a https://github.com/near/nearcore.
+It's a reduced implementation of near primitives.
+"""
+
+[dependencies]
+borsh = "0.9"
+common-api = { path = "../common-api" }
+chrono = { version = "0.4", features = ["serde"] }
+serde = { version = "1", default-features = false, features = ["derive", "rc"] }
+near-primitives-core = "0.15"

near-primitives-light/src/errors.rs

@@ -0,0 +1,823 @@
+use serde::{Deserialize, Serialize};
+use std::fmt::{Debug, Display};
+
+use near_primitives_core::{
+    hash::CryptoHash,
+    serialize::dec_format,
+    types::{AccountId, Balance, Gas, Nonce},
+};
+
+use common_api::crypto::prelude::*;
+
+use borsh::{BorshDeserialize, BorshSerialize};
+
+/// Error returned in the ExecutionOutcome in case of failure
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub enum TxExecutionError {
+    /// An error happened during Action execution
+    ActionError(ActionError),
+    /// An error happened during Transaction execution
+    InvalidTxError(InvalidTxError),
+}
+
+impl std::error::Error for TxExecutionError {}
+
+impl Display for TxExecutionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            TxExecutionError::ActionError(e) => write!(f, "{}", e),
+            TxExecutionError::InvalidTxError(e) => write!(f, "{}", e),
+        }
+    }
+}
+
+impl From<ActionError> for TxExecutionError {
+    fn from(error: ActionError) -> Self {
+        TxExecutionError::ActionError(error)
+    }
+}
+
+impl From<InvalidTxError> for TxExecutionError {
+    fn from(error: InvalidTxError) -> Self {
+        TxExecutionError::InvalidTxError(error)
+    }
+}
+
+/// Error returned from `Runtime::apply`
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RuntimeError {
+    /// An unexpected integer overflow occurred. The likely issue is an invalid state or the transition.
+    UnexpectedIntegerOverflow,
+    /// An error happened during TX verification and account charging. It's likely the chunk is invalid.
+    /// and should be challenged.
+    InvalidTxError(InvalidTxError),
+    /// Unexpected error which is typically related to the node storage corruption.
+    /// It's possible the input state is invalid or malicious.
+    StorageError(StorageError),
+    /// An error happens if `check_balance` fails, which is likely an indication of an invalid state.
+    BalanceMismatchError(BalanceMismatchError),
+    /// The incoming receipt didn't pass the validation, it's likely a malicious behaviour.
+    ReceiptValidationError(ReceiptValidationError),
+    /// Error when accessing validator information. Happens inside epoch manager.
+    ValidatorError(EpochError),
+}
+
+impl std::fmt::Display for RuntimeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        f.write_str(&format!("{:?}", self))
+    }
+}
+
+impl std::error::Error for RuntimeError {}
+
+/// Internal
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum StorageError {
+    /// Key-value db internal failure
+    StorageInternalError,
+    /// Storage is PartialStorage and requested a missing trie node
+    TrieNodeMissing,
+    /// Either invalid state or key-value db is corrupted.
+    /// For PartialStorage it cannot be corrupted.
+    /// Error message is unreliable and for debugging purposes only. It's also probably ok to
+    /// panic in every place that produces this error.
+    /// We can check if db is corrupted by verifying everything in the state trie.
+    StorageInconsistentState(String),
+    /// Error from flat storage
+    FlatStorageError(String),
+}
+
+impl std::fmt::Display for StorageError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        f.write_str(&format!("{:?}", self))
+    }
+}
+
+impl std::error::Error for StorageError {}
+
+/// An error happened during TX execution
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub enum InvalidTxError {
+    /// Happens if a wrong AccessKey used or AccessKey has not enough permissions
+    InvalidAccessKeyError(InvalidAccessKeyError),
+    /// TX signer_id is not a valid [`AccountId`]
+    InvalidSignerId { signer_id: String },
+    /// TX signer_id is not found in a storage
+    SignerDoesNotExist { signer_id: AccountId },
+    /// Transaction nonce must be `account[access_key].nonce + 1`.
+    InvalidNonce { tx_nonce: Nonce, ak_nonce: Nonce },
+    /// Transaction nonce is larger than the upper bound given by the block height
+    NonceTooLarge { tx_nonce: Nonce, upper_bound: Nonce },
+    /// TX receiver_id is not a valid AccountId
+    InvalidReceiverId { receiver_id: String },
+    /// TX signature is not valid
+    InvalidSignature,
+    /// Account does not have enough balance to cover TX cost
+    NotEnoughBalance {
+        signer_id: AccountId,
+        #[serde(with = "dec_format")]
+        balance: Balance,
+        #[serde(with = "dec_format")]
+        cost: Balance,
+    },
+    /// Signer account doesn't have enough balance after transaction.
+    LackBalanceForState {
+        /// An account which doesn't have enough balance to cover storage.
+        signer_id: AccountId,
+        /// Required balance to cover the state.
+        #[serde(with = "dec_format")]
+        amount: Balance,
+    },
+    /// An integer overflow occurred during transaction cost estimation.
+    CostOverflow,
+    /// Transaction parent block hash doesn't belong to the current chain
+    InvalidChain,
+    /// Transaction has expired
+    Expired,
+    /// An error occurred while validating actions of a Transaction.
+    ActionsValidation(ActionsValidationError),
+    /// The size of serialized transaction exceeded the limit.
+    TransactionSizeExceeded { size: u64, limit: u64 },
+}
+
+impl std::error::Error for InvalidTxError {}
+
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub enum InvalidAccessKeyError {
+    /// The access key identified by the `public_key` doesn't exist for the account
+    AccessKeyNotFound {
+        account_id: AccountId,
+        public_key: Ed25519PublicKey,
+    },
+    /// Transaction `receiver_id` doesn't match the access key receiver_id
+    ReceiverMismatch {
+        tx_receiver: AccountId,
+        ak_receiver: String,
+    },
+    /// Transaction method name isn't allowed by the access key
+    MethodNameMismatch { method_name: String },
+    /// Transaction requires a full permission access key.
+    RequiresFullAccess,
+    /// Access Key does not have enough allowance to cover transaction cost
+    NotEnoughAllowance {
+        account_id: AccountId,
+        public_key: Ed25519PublicKey,
+        #[serde(with = "dec_format")]
+        allowance: Balance,
+        #[serde(with = "dec_format")]
+        cost: Balance,
+    },
+    /// Having a deposit with a function call action is not allowed with a function call access key.
+    DepositWithFunctionCall,
+}
+
+/// Describes the error for validating a list of actions.
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub enum ActionsValidationError {
+    /// The delete action must be a final aciton in transaction
+    DeleteActionMustBeFinal,
+    /// The total prepaid gas (for all given actions) exceeded the limit.
+    TotalPrepaidGasExceeded { total_prepaid_gas: Gas, limit: Gas },
+    /// The number of actions exceeded the given limit.
+    TotalNumberOfActionsExceeded {
+        total_number_of_actions: u64,
+        limit: u64,
+    },
+    /// The total number of bytes of the method names exceeded the limit in a Add Key action.
+    AddKeyMethodNamesNumberOfBytesExceeded {
+        total_number_of_bytes: u64,
+        limit: u64,
+    },
+    /// The length of some method name exceeded the limit in a Add Key action.
+    AddKeyMethodNameLengthExceeded { length: u64, limit: u64 },
+    /// Integer overflow during a compute.
+    IntegerOverflow,
+    /// Invalid account ID.
+    InvalidAccountId { account_id: String },
+    /// The size of the contract code exceeded the limit in a DeployContract action.
+    ContractSizeExceeded { size: u64, limit: u64 },
+    /// The length of the method name exceeded the limit in a Function Call action.
+    FunctionCallMethodNameLengthExceeded { length: u64, limit: u64 },
+    /// The length of the arguments exceeded the limit in a Function Call action.
+    FunctionCallArgumentsLengthExceeded { length: u64, limit: u64 },
+    /// An attempt to stake with a public key that is not convertible to ristretto.
+    UnsuitableStakingKey { public_key: Ed25519PublicKey },
+    /// The attached amount of gas in a FunctionCall action has to be a positive number.
+    FunctionCallZeroAttachedGas,
+}
+
+/// Describes the error for validating a receipt.
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub enum ReceiptValidationError {
+    /// The `predecessor_id` of a Receipt is not valid.
+    InvalidPredecessorId { account_id: String },
+    /// The `receiver_id` of a Receipt is not valid.
+    InvalidReceiverId { account_id: String },
+    /// The `signer_id` of an ActionReceipt is not valid.
+    InvalidSignerId { account_id: String },
+    /// The `receiver_id` of a DataReceiver within an ActionReceipt is not valid.
+    InvalidDataReceiverId { account_id: String },
+    /// The length of the returned data exceeded the limit in a DataReceipt.
+    ReturnedValueLengthExceeded { length: u64, limit: u64 },
+    /// The number of input data dependencies exceeds the limit in an ActionReceipt.
+    NumberInputDataDependenciesExceeded {
+        number_of_input_data_dependencies: u64,
+        limit: u64,
+    },
+    /// An error occurred while validating actions of an ActionReceipt.
+    ActionsValidation(ActionsValidationError),
+}
+
+impl Display for ReceiptValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            ReceiptValidationError::InvalidPredecessorId { account_id } => {
+                write!(f, "The predecessor_id `{}` of a Receipt is not valid.", account_id)
+            }
+            ReceiptValidationError::InvalidReceiverId { account_id } => {
+                write!(f, "The receiver_id `{}` of a Receipt is not valid.", account_id)
+            }
+            ReceiptValidationError::InvalidSignerId { account_id } => {
+                write!(f, "The signer_id `{}` of an ActionReceipt is not valid.", account_id)
+            }
+            ReceiptValidationError::InvalidDataReceiverId { account_id } => write!(
+                f,
+                "The receiver_id `{}` of a DataReceiver within an ActionReceipt is not valid.",
+                account_id
+            ),
+            ReceiptValidationError::ReturnedValueLengthExceeded { length, limit } => write!(
+                f,
+                "The length of the returned data {} exceeded the limit {} in a DataReceipt",
+                length, limit
+            ),
+            ReceiptValidationError::NumberInputDataDependenciesExceeded { number_of_input_data_dependencies, limit } => write!(
+                f,
+                "The number of input data dependencies {} exceeded the limit {} in an ActionReceipt",
+                number_of_input_data_dependencies, limit
+            ),
+            ReceiptValidationError::ActionsValidation(e) => write!(f, "{}", e),
+        }
+    }
+}
+
+impl std::error::Error for ReceiptValidationError {}
+
+impl Display for ActionsValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            ActionsValidationError::DeleteActionMustBeFinal => {
+                write!(f, "The delete action must be the last action in transaction")
+            }
+            ActionsValidationError::TotalPrepaidGasExceeded { total_prepaid_gas, limit } => {
+                write!(f, "The total prepaid gas {} exceeds the limit {}", total_prepaid_gas, limit)
+            }
+            ActionsValidationError::TotalNumberOfActionsExceeded {total_number_of_actions, limit } => {
+                write!(
+                    f,
+                    "The total number of actions {} exceeds the limit {}",
+                    total_number_of_actions, limit
+                )
+            }
+            ActionsValidationError::AddKeyMethodNamesNumberOfBytesExceeded { total_number_of_bytes, limit } => write!(
+                f,
+                "The total number of bytes in allowed method names {} exceeds the maximum allowed number {} in a AddKey action",
+                total_number_of_bytes, limit
+            ),
+            ActionsValidationError::AddKeyMethodNameLengthExceeded { length, limit } => write!(
+                f,
+                "The length of some method name {} exceeds the maximum allowed length {} in a AddKey action",
+                length, limit
+            ),
+            ActionsValidationError::IntegerOverflow => write!(
+                f,
+                "Integer overflow during a compute",
+            ),
+            ActionsValidationError::InvalidAccountId { account_id } => write!(
+                f,
+                "Invalid account ID `{}`",
+                account_id
+            ),
+            ActionsValidationError::ContractSizeExceeded { size, limit } => write!(
+                f,
+                "The length of the contract size {} exceeds the maximum allowed size {} in a DeployContract action",
+                size, limit
+            ),
+            ActionsValidationError::FunctionCallMethodNameLengthExceeded { length, limit } => write!(
+                f,
+                "The length of the method name {} exceeds the maximum allowed length {} in a FunctionCall action",
+                length, limit
+            ),
+            ActionsValidationError::FunctionCallArgumentsLengthExceeded { length, limit } => write!(
+                f,
+                "The length of the arguments {} exceeds the maximum allowed length {} in a FunctionCall action",
+                length, limit
+            ),
+            ActionsValidationError::UnsuitableStakingKey { public_key } => write!(
+                f,
+                "The staking key must be ristretto compatible ED25519 key. {} is provided instead.",
+                public_key,
+            ),
+            ActionsValidationError::FunctionCallZeroAttachedGas => write!(
+                f,
+                "The attached amount of gas in a FunctionCall action has to be a positive number",
+            ),
+        }
+    }
+}
+
+impl std::error::Error for ActionsValidationError {}
+
+/// An error happened during Action execution
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct ActionError {
+    /// Index of the failed action in the transaction.
+    /// Action index is not defined if ActionError.kind is `ActionErrorKind::LackBalanceForState`
+    pub index: Option<u64>,
+    /// The kind of ActionError happened
+    pub kind: ActionErrorKind,
+}
+
+impl std::error::Error for ActionError {}
+
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub enum ActionErrorKind {
+    /// Happens when CreateAccount action tries to create an account with account_id which is already exists in the storage
+    AccountAlreadyExists { account_id: AccountId },
+    /// Happens when TX receiver_id doesn't exist (but action is not Action::CreateAccount)
+    AccountDoesNotExist { account_id: AccountId },
+    /// A top-level account ID can only be created by registrar.
+    CreateAccountOnlyByRegistrar {
+        account_id: AccountId,
+        registrar_account_id: AccountId,
+        predecessor_id: AccountId,
+    },
+    /// A newly created account must be under a namespace of the creator account
+    CreateAccountNotAllowed {
+        account_id: AccountId,
+        predecessor_id: AccountId,
+    },
+    /// Administrative actions like `DeployContract`, `Stake`, `AddKey`, `DeleteKey`. can be proceed only if sender=receiver
+    /// or the first TX action is a `CreateAccount` action
+    ActorNoPermission {
+        account_id: AccountId,
+        actor_id: AccountId,
+    },
+    /// Account tries to remove an access key that doesn't exist
+    DeleteKeyDoesNotExist {
+        account_id: AccountId,
+        public_key: Ed25519PublicKey,
+    },
+    /// The public key is already used for an existing access key
+    AddKeyAlreadyExists {
+        account_id: AccountId,
+        public_key: Ed25519PublicKey,
+    },
+    /// Account is staking and can not be deleted
+    DeleteAccountStaking { account_id: AccountId },
+    /// ActionReceipt can't be completed, because the remaining balance will not be enough to cover storage.
+    LackBalanceForState {
+        /// An account which needs balance
+        account_id: AccountId,
+        /// Balance required to complete an action.
+        #[serde(with = "dec_format")]
+        amount: Balance,
+    },
+    /// Account is not yet staked, but tries to unstake
+    TriesToUnstake { account_id: AccountId },
+    /// The account doesn't have enough balance to increase the stake.
+    TriesToStake {
+        account_id: AccountId,
+        #[serde(with = "dec_format")]
+        stake: Balance,
+        #[serde(with = "dec_format")]
+        locked: Balance,
+        #[serde(with = "dec_format")]
+        balance: Balance,
+    },
+    InsufficientStake {
+        account_id: AccountId,
+        #[serde(with = "dec_format")]
+        stake: Balance,
+        #[serde(with = "dec_format")]
+        minimum_stake: Balance,
+    },
+    /// 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 },
+    /// Delete account whose state is large is temporarily banned.
+    DeleteAccountWithLargeState { account_id: AccountId },
+}
+
+impl From<ActionErrorKind> for ActionError {
+    fn from(e: ActionErrorKind) -> ActionError {
+        ActionError {
+            index: None,
+            kind: e,
+        }
+    }
+}
+
+impl Display for InvalidTxError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            InvalidTxError::InvalidSignerId { signer_id } => {
+                write!(
+                    f,
+                    "Invalid signer account ID {:?} according to requirements",
+                    signer_id
+                )
+            }
+            InvalidTxError::SignerDoesNotExist { signer_id } => {
+                write!(f, "Signer {:?} does not exist", signer_id)
+            }
+            InvalidTxError::InvalidAccessKeyError(access_key_error) => {
+                Display::fmt(&access_key_error, f)
+            }
+            InvalidTxError::InvalidNonce { tx_nonce, ak_nonce } => write!(
+                f,
+                "Transaction nonce {} must be larger than nonce of the used access key {}",
+                tx_nonce, ak_nonce
+            ),
+            InvalidTxError::InvalidReceiverId { receiver_id } => {
+                write!(
+                    f,
+                    "Invalid receiver account ID {:?} according to requirements",
+                    receiver_id
+                )
+            }
+            InvalidTxError::InvalidSignature => {
+                write!(f, "Transaction is not signed with the given public key")
+            }
+            InvalidTxError::NotEnoughBalance {
+                signer_id,
+                balance,
+                cost,
+            } => write!(
+                f,
+                "Sender {:?} does not have enough balance {} for operation costing {}",
+                signer_id, balance, cost
+            ),
+            InvalidTxError::LackBalanceForState { signer_id, amount } => {
+                write!(f, "Failed to execute, because the account {:?} wouldn't have enough balance to cover storage, required to have {} yoctoNEAR more", signer_id, amount)
+            }
+            InvalidTxError::CostOverflow => {
+                write!(f, "Transaction gas or balance cost is too high")
+            }
+            InvalidTxError::InvalidChain => {
+                write!(
+                    f,
+                    "Transaction parent block hash doesn't belong to the current chain"
+                )
+            }
+            InvalidTxError::Expired => {
+                write!(f, "Transaction has expired")
+            }
+            InvalidTxError::ActionsValidation(error) => {
+                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
+                )
+            }
+            InvalidTxError::TransactionSizeExceeded { size, limit } => {
+                write!(
+                    f,
+                    "Size of serialized transaction {} exceeded the limit {}",
+                    size, limit
+                )
+            }
+        }
+    }
+}
+
+impl From<InvalidAccessKeyError> for InvalidTxError {
+    fn from(error: InvalidAccessKeyError) -> Self {
+        InvalidTxError::InvalidAccessKeyError(error)
+    }
+}
+
+impl Display for InvalidAccessKeyError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            InvalidAccessKeyError::AccessKeyNotFound {
+                account_id,
+                public_key,
+            } => write!(
+                f,
+                "Signer {:?} doesn't have access key with the given public_key {}",
+                account_id, public_key
+            ),
+            InvalidAccessKeyError::ReceiverMismatch {
+                tx_receiver,
+                ak_receiver,
+            } => write!(
+                f,
+                "Transaction receiver_id {:?} doesn't match the access key receiver_id {:?}",
+                tx_receiver, ak_receiver
+            ),
+            InvalidAccessKeyError::MethodNameMismatch { method_name } => write!(
+                f,
+                "Transaction method name {:?} isn't allowed by the access key",
+                method_name
+            ),
+            InvalidAccessKeyError::RequiresFullAccess => {
+                write!(f, "Invalid access key type. Full-access keys are required for transactions that have multiple or non-function-call actions")
+            }
+            InvalidAccessKeyError::NotEnoughAllowance {
+                account_id,
+                public_key,
+                allowance,
+                cost,
+            } => write!(
+                f,
+                "Access Key {:?}:{} does not have enough balance {} for transaction costing {}",
+                account_id, public_key, allowance, cost
+            ),
+            InvalidAccessKeyError::DepositWithFunctionCall => {
+                write!(f, "Having a deposit with a function call action is not allowed with a function call access key.")
+            }
+        }
+    }
+}
+
+impl std::error::Error for InvalidAccessKeyError {}
+
+/// Happens when the input balance doesn't match the output balance in Runtime apply.
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct BalanceMismatchError {
+    // Input balances
+    #[serde(with = "dec_format")]
+    pub incoming_validator_rewards: Balance,
+    #[serde(with = "dec_format")]
+    pub initial_accounts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub incoming_receipts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub processed_delayed_receipts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub initial_postponed_receipts_balance: Balance,
+    // Output balances
+    #[serde(with = "dec_format")]
+    pub final_accounts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub outgoing_receipts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub new_delayed_receipts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub final_postponed_receipts_balance: Balance,
+    #[serde(with = "dec_format")]
+    pub tx_burnt_amount: Balance,
+    #[serde(with = "dec_format")]
+    pub slashed_burnt_amount: Balance,
+    #[serde(with = "dec_format")]
+    pub other_burnt_amount: Balance,
+}
+
+impl Display for BalanceMismatchError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        // Using saturating add to avoid overflow in display
+        let initial_balance = self
+            .incoming_validator_rewards
+            .saturating_add(self.initial_accounts_balance)
+            .saturating_add(self.incoming_receipts_balance)
+            .saturating_add(self.processed_delayed_receipts_balance)
+            .saturating_add(self.initial_postponed_receipts_balance);
+        let final_balance = self
+            .final_accounts_balance
+            .saturating_add(self.outgoing_receipts_balance)
+            .saturating_add(self.new_delayed_receipts_balance)
+            .saturating_add(self.final_postponed_receipts_balance)
+            .saturating_add(self.tx_burnt_amount)
+            .saturating_add(self.slashed_burnt_amount)
+            .saturating_add(self.other_burnt_amount);
+        write!(
+            f,
+            "Balance Mismatch Error. The input balance {} doesn't match output balance {}\n\
+             Inputs:\n\
+             \tIncoming validator rewards sum: {}\n\
+             \tInitial accounts balance sum: {}\n\
+             \tIncoming receipts balance sum: {}\n\
+             \tProcessed delayed receipts balance sum: {}\n\
+             \tInitial postponed receipts balance sum: {}\n\
+             Outputs:\n\
+             \tFinal accounts balance sum: {}\n\
+             \tOutgoing receipts balance sum: {}\n\
+             \tNew delayed receipts balance sum: {}\n\
+             \tFinal postponed receipts balance sum: {}\n\
+             \tTx fees burnt amount: {}\n\
+             \tSlashed amount: {}\n\
+             \tOther burnt amount: {}",
+            initial_balance,
+            final_balance,
+            self.incoming_validator_rewards,
+            self.initial_accounts_balance,
+            self.incoming_receipts_balance,
+            self.processed_delayed_receipts_balance,
+            self.initial_postponed_receipts_balance,
+            self.final_accounts_balance,
+            self.outgoing_receipts_balance,
+            self.new_delayed_receipts_balance,
+            self.final_postponed_receipts_balance,
+            self.tx_burnt_amount,
+            self.slashed_burnt_amount,
+            self.other_burnt_amount,
+        )
+    }
+}
+
+impl std::error::Error for BalanceMismatchError {}
+
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone, PartialEq, Eq)]
+pub struct IntegerOverflowError;
+
+impl std::fmt::Display for IntegerOverflowError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        f.write_str(&format!("{:?}", self))
+    }
+}
+
+impl std::error::Error for IntegerOverflowError {}
+
+impl From<IntegerOverflowError> for InvalidTxError {
+    fn from(_: IntegerOverflowError) -> Self {
+        InvalidTxError::CostOverflow
+    }
+}
+
+impl From<IntegerOverflowError> for RuntimeError {
+    fn from(_: IntegerOverflowError) -> Self {
+        RuntimeError::UnexpectedIntegerOverflow
+    }
+}
+
+impl From<StorageError> for RuntimeError {
+    fn from(e: StorageError) -> Self {
+        RuntimeError::StorageError(e)
+    }
+}
+
+impl From<BalanceMismatchError> for RuntimeError {
+    fn from(e: BalanceMismatchError) -> Self {
+        RuntimeError::BalanceMismatchError(e)
+    }
+}
+
+impl From<InvalidTxError> for RuntimeError {
+    fn from(e: InvalidTxError) -> Self {
+        RuntimeError::InvalidTxError(e)
+    }
+}
+
+impl From<EpochError> for RuntimeError {
+    fn from(e: EpochError) -> Self {
+        RuntimeError::ValidatorError(e)
+    }
+}
+
+impl Display for ActionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(
+            f,
+            "Action #{}: {}",
+            self.index.unwrap_or_default(),
+            self.kind
+        )
+    }
+}
+
+impl Display for ActionErrorKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            ActionErrorKind::AccountAlreadyExists { account_id } => {
+                write!(f, "Can't create a new account {:?}, because it already exists", account_id)
+            }
+            ActionErrorKind::AccountDoesNotExist { account_id } => write!(
+                f,
+                "Can't complete the action because account {:?} doesn't exist",
+                account_id
+            ),
+            ActionErrorKind::ActorNoPermission { actor_id, account_id } => write!(
+                f,
+                "Actor {:?} doesn't have permission to account {:?} to complete the action",
+                actor_id, account_id
+            ),
+            ActionErrorKind::LackBalanceForState { account_id, amount } => write!(
+                f,
+                "The account {} wouldn't have enough balance to cover storage, required to have {} yoctoNEAR more",
+                account_id, amount
+            ),
+            ActionErrorKind::TriesToUnstake { account_id } => {
+                write!(f, "Account {:?} is not yet staked, but tries to unstake", account_id)
+            }
+            ActionErrorKind::TriesToStake { account_id, stake, locked, balance } => write!(
+                f,
+                "Account {:?} tries to stake {}, but has staked {} and only has {}",
+                account_id, stake, locked, balance
+            ),
+            ActionErrorKind::CreateAccountOnlyByRegistrar { account_id, registrar_account_id, predecessor_id } => write!(
+                f,
+                "A top-level account ID {:?} can't be created by {:?}, short top-level account IDs can only be created by {:?}",
+                account_id, predecessor_id, registrar_account_id,
+            ),
+            ActionErrorKind::CreateAccountNotAllowed { account_id, predecessor_id } => write!(
+                f,
+                "A sub-account ID {:?} can't be created by account {:?}",
+                account_id, predecessor_id,
+            ),
+            ActionErrorKind::DeleteKeyDoesNotExist { account_id, .. } => write!(
+                f,
+                "Account {:?} tries to remove an access key that doesn't exist",
+                account_id
+            ),
+            ActionErrorKind::AddKeyAlreadyExists { public_key, .. } => write!(
+                f,
+                "The public key {:?} is already used for an existing access key",
+                public_key
+            ),
+            ActionErrorKind::DeleteAccountStaking { account_id } => {
+                write!(f, "Account {:?} is staking and can not be deleted", account_id)
+            }
+            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),
+            ActionErrorKind::DeleteAccountWithLargeState { account_id } => write!(f, "The state of account {} is too large and therefore cannot be deleted", account_id),
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Clone)]
+pub enum EpochError {
+    /// Error calculating threshold from given stakes for given number of seats.
+    /// Only should happened if calling code doesn't check for integer value of stake > number of seats.
+    ThresholdError { stake_sum: Balance, num_seats: u64 },
+    /// Missing block hash in the storage (means there is some structural issue).
+    MissingBlock(CryptoHash),
+    /// Error due to IO (DB read/write, serialization, etc.).
+    IOErr(String),
+    /// Error getting information for a shard
+    ShardingError(String),
+    NotEnoughValidators {
+        num_validators: u64,
+        num_shards: u64,
+    },
+}
+
+impl std::error::Error for EpochError {}
+
+impl Display for EpochError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            EpochError::ThresholdError {
+                stake_sum,
+                num_seats,
+            } => write!(
+                f,
+                "Total stake {} must be higher than the number of seats {}",
+                stake_sum, num_seats
+            ),
+            EpochError::MissingBlock(hash) => write!(f, "Missing block {}", hash),
+            EpochError::IOErr(err) => write!(f, "IO: {}", err),
+            EpochError::ShardingError(err) => write!(f, "Sharding Error: {}", err),
+            EpochError::NotEnoughValidators {
+                num_shards,
+                num_validators,
+            } => {
+                write!(f, "There were not enough validator proposals to fill all shards. num_proposals: {}, num_shards: {}", num_validators, num_shards)
+            }
+        }
+    }
+}
+
+impl Debug for EpochError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            EpochError::ThresholdError {
+                stake_sum,
+                num_seats,
+            } => {
+                write!(f, "ThresholdError({}, {})", stake_sum, num_seats)
+            }
+            EpochError::MissingBlock(hash) => write!(f, "MissingBlock({})", hash),
+            EpochError::IOErr(err) => write!(f, "IOErr({})", err),
+            EpochError::ShardingError(err) => write!(f, "ShardingError({})", err),
+            EpochError::NotEnoughValidators {
+                num_shards,
+                num_validators,
+            } => {
+                write!(f, "NotEnoughValidators({}, {})", num_validators, num_shards)
+            }
+        }
+    }
+}
+
+impl From<std::io::Error> for EpochError {
+    fn from(error: std::io::Error) -> Self {
+        EpochError::IOErr(error.to_string())
+    }
+}

near-primitives-light/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod errors;
+pub mod receipt;
+pub mod transaction;
+pub mod types;
+pub mod views;

near-primitives-light/src/receipt.rs

@@ -0,0 +1,179 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use near_primitives_core::{
+    hash::CryptoHash,
+    serialize::{dec_format, option_base64_format, to_base58},
+    types::{AccountId, Balance, ShardId},
+};
+use serde::{Deserialize, Serialize};
+use std::{borrow::Borrow, collections::HashMap, fmt, hash::Hash};
+
+use crate::transaction::*;
+use common_api::crypto::prelude::*;
+
+/// Receipts are used for a cross-shard communication.
+/// Receipts could be 2 types (determined by a `ReceiptEnum`): `ReceiptEnum::Action` of `ReceiptEnum::Data`.
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
+pub struct Receipt {
+    /// An issuer account_id of a particular receipt.
+    /// `predecessor_id` could be either `Transaction` `signer_id` or intermediate contract's `account_id`.
+    pub predecessor_id: AccountId,
+    /// `receiver_id` is a receipt destination.
+    pub receiver_id: AccountId,
+    /// An unique id for the receipt
+    pub receipt_id: CryptoHash,
+    /// A receipt type
+    pub receipt: ReceiptEnum,
+}
+
+impl Borrow<CryptoHash> for Receipt {
+    fn borrow(&self) -> &CryptoHash {
+        &self.receipt_id
+    }
+}
+
+impl Receipt {
+    /// It's not a content hash, but receipt_id is unique.
+    pub fn get_hash(&self) -> CryptoHash {
+        self.receipt_id
+    }
+
+    /// Generates a receipt with a transfer from system for a given balance without a receipt_id.
+    /// This should be used for token refunds instead of gas refunds. It doesn't refund the
+    /// allowance of the access key. For gas refunds use `new_gas_refund`.
+    pub fn new_balance_refund(receiver_id: &AccountId, refund: Balance) -> Self {
+        Receipt {
+            predecessor_id: "system".parse().unwrap(),
+            receiver_id: receiver_id.clone(),
+            receipt_id: CryptoHash::default(),
+
+            receipt: ReceiptEnum::Action(ActionReceipt {
+                signer_id: "system".parse().unwrap(),
+                signer_public_key: Ed25519PublicKey::try_from_bytes(&[0; 32]).unwrap(),
+                gas_price: 0,
+                output_data_receivers: vec![],
+                input_data_ids: vec![],
+                actions: vec![Action::Transfer(TransferAction { deposit: refund })],
+            }),
+        }
+    }
+
+    /// Generates a receipt with a transfer action from system for a given balance without a
+    /// receipt_id. It contains `signer_id` and `signer_public_key` to indicate this is a gas
+    /// refund. The execution of this receipt will try to refund the allowance of the
+    /// access key with the given public key.
+    /// NOTE: The access key may be replaced by the owner, so the execution can't rely that the
+    /// access key is the same and it should use best effort for the refund.
+    pub fn new_gas_refund(
+        receiver_id: &AccountId,
+        refund: Balance,
+        signer_public_key: Ed25519PublicKey,
+    ) -> Self {
+        Receipt {
+            predecessor_id: "system".parse().unwrap(),
+            receiver_id: receiver_id.clone(),
+            receipt_id: CryptoHash::default(),
+
+            receipt: ReceiptEnum::Action(ActionReceipt {
+                signer_id: receiver_id.clone(),
+                signer_public_key,
+                gas_price: 0,
+                output_data_receivers: vec![],
+                input_data_ids: vec![],
+                actions: vec![Action::Transfer(TransferAction { deposit: refund })],
+            }),
+        }
+    }
+}
+
+/// Receipt could be either ActionReceipt or DataReceipt
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+#[allow(clippy::large_enum_variant)]
+pub enum ReceiptEnum {
+    Action(ActionReceipt),
+    Data(DataReceipt),
+}
+
+/// ActionReceipt is derived from an Action from `Transaction or from Receipt`
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
+pub struct ActionReceipt {
+    /// A signer of the original transaction
+    pub signer_id: AccountId,
+    /// An access key which was used to sign the original transaction
+    pub signer_public_key: Ed25519PublicKey,
+    /// A gas_price which has been used to buy gas in the original transaction
+    #[serde(with = "dec_format")]
+    pub gas_price: Balance,
+    /// If present, where to route the output data
+    pub output_data_receivers: Vec<DataReceiver>,
+    /// A list of the input data dependencies for this Receipt to process.
+    /// If all `input_data_ids` for this receipt are delivered to the account
+    /// that means we have all the `ReceivedData` input which will be than converted to a
+    /// `PromiseResult::Successful(value)` or `PromiseResult::Failed`
+    /// depending on `ReceivedData` is `Some(_)` or `None`
+    pub input_data_ids: Vec<CryptoHash>,
+    /// A list of actions to process when all input_data_ids are filled
+    pub actions: Vec<Action>,
+}
+
+/// An incoming (ingress) `DataReceipt` which is going to a Receipt's `receiver` input_data_ids
+/// Which will be converted to `PromiseResult::Successful(value)` or `PromiseResult::Failed`
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Hash, PartialEq, Eq, Clone)]
+pub struct DataReceipt {
+    pub data_id: CryptoHash,
+    #[serde(with = "option_base64_format")]
+    pub data: Option<Vec<u8>>,
+}
+
+impl fmt::Debug for DataReceipt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("DataReceipt")
+            .field("data_id", &self.data_id)
+            .field(
+                "data",
+                &format_args!("{:?}", self.data.as_deref().map(to_base58)),
+            )
+            .finish()
+    }
+}
+
+/// The outgoing (egress) data which will be transformed
+/// to a `DataReceipt` to be sent to a `receipt.receiver`
+#[derive(
+    BorshSerialize, BorshDeserialize, Serialize, Deserialize, Hash, Clone, Debug, PartialEq, Eq,
+)]
+pub struct DataReceiver {
+    pub data_id: CryptoHash,
+    pub receiver_id: AccountId,
+}
+
+/// A temporary data which is created by processing of DataReceipt
+/// stored in a state trie with a key = `account_id` + `data_id` until
+/// `input_data_ids` of all incoming Receipts are satisfied
+/// None means data retrieval was failed
+#[derive(BorshSerialize, BorshDeserialize, Hash, PartialEq, Eq, Clone)]
+pub struct ReceivedData {
+    pub data: Option<Vec<u8>>,
+}
+
+impl fmt::Debug for ReceivedData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ReceivedData")
+            .field(
+                "data",
+                &format_args!("{:?}", self.data.as_deref().map(to_base58)),
+            )
+            .finish()
+    }
+}
+
+/// Stores indices for a persistent queue for delayed receipts that didn't fit into a block.
+#[derive(Default, BorshSerialize, BorshDeserialize, Clone, PartialEq, Eq, Debug)]
+pub struct DelayedReceiptIndices {
+    // First inclusive index in the queue.
+    pub first_index: u64,
+    // Exclusive end index of the queue
+    pub next_available_index: u64,
+}
+
+/// Map of shard to list of receipts to send to it.
+pub type ReceiptResult = HashMap<ShardId, Vec<Receipt>>;

near-primitives-light/src/transaction.rs

@@ -0,0 +1,411 @@
+use std::{
+    borrow::Borrow,
+    fmt,
+    hash::{Hash, Hasher},
+    str::FromStr,
+};
+
+use borsh::{BorshDeserialize, BorshSerialize};
+use common_api::crypto::prelude::*;
+use near_primitives_core::{
+    account::AccessKey,
+    hash::{hash, CryptoHash},
+    profile::ProfileData,
+    serialize::{base64_format, dec_format, to_base58},
+    types::{AccountId, Balance, Gas, Nonce},
+};
+use serde::{Deserialize, Serialize};
+
+use crate::errors::TxExecutionError;
+
+pub type LogEntry = String;
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub struct Transaction {
+    /// An account on which behalf transaction is signed
+    pub signer_id: AccountId,
+    /// A public key of the access key which was used to sign an account.
+    /// Access key holds permissions for calling certain kinds of actions.
+    pub public_key: Ed25519PublicKey,
+    /// Nonce is used to determine order of transaction in the pool.
+    /// It increments for a combination of `signer_id` and `public_key`
+    pub nonce: Nonce,
+    /// Receiver account for this transaction
+    pub receiver_id: AccountId,
+    /// The hash of the block in the blockchain on top of which the given transaction is valid
+    pub block_hash: CryptoHash,
+    /// A list of actions to be applied
+    pub actions: Vec<Action>,
+}
+
+impl Transaction {
+    /// Computes a hash of the transaction for signing and size of serialized transaction
+    pub fn get_hash_and_size(&self) -> (CryptoHash, u64) {
+        let bytes = self.try_to_vec().expect("Failed to deserialize");
+        (hash(&bytes), bytes.len() as u64)
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub enum Action {
+    /// Create an (sub)account using a transaction `receiver_id` as an ID for
+    /// a new account ID must pass validation rules described here
+    /// <http://nomicon.io/Primitives/Account.html>.
+    CreateAccount(CreateAccountAction),
+    /// Sets a Wasm code to a receiver_id
+    DeployContract(DeployContractAction),
+    FunctionCall(FunctionCallAction),
+    Transfer(TransferAction),
+    Stake(StakeAction),
+    AddKey(AddKeyAction),
+    DeleteKey(DeleteKeyAction),
+    DeleteAccount(DeleteAccountAction),
+}
+
+impl Action {
+    pub fn get_prepaid_gas(&self) -> Gas {
+        match self {
+            Action::FunctionCall(a) => a.gas,
+            _ => 0,
+        }
+    }
+    pub fn get_deposit_balance(&self) -> Balance {
+        match self {
+            Action::FunctionCall(a) => a.deposit,
+            Action::Transfer(a) => a.deposit,
+            _ => 0,
+        }
+    }
+}
+
+/// Create account action
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct CreateAccountAction {}
+
+impl From<CreateAccountAction> for Action {
+    fn from(create_account_action: CreateAccountAction) -> Self {
+        Self::CreateAccount(create_account_action)
+    }
+}
+
+/// Deploy contract action
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone)]
+pub struct DeployContractAction {
+    /// WebAssembly binary
+    #[serde(with = "base64_format")]
+    pub code: Vec<u8>,
+}
+
+impl From<DeployContractAction> for Action {
+    fn from(deploy_contract_action: DeployContractAction) -> Self {
+        Self::DeployContract(deploy_contract_action)
+    }
+}
+
+impl fmt::Debug for DeployContractAction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("DeployContractAction").finish()
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone)]
+pub struct FunctionCallAction {
+    pub method_name: String,
+    #[serde(with = "base64_format")]
+    pub args: Vec<u8>,
+    pub gas: Gas,
+    #[serde(with = "dec_format")]
+    pub deposit: Balance,
+}
+
+impl From<FunctionCallAction> for Action {
+    fn from(function_call_action: FunctionCallAction) -> Self {
+        Self::FunctionCall(function_call_action)
+    }
+}
+
+impl fmt::Debug for FunctionCallAction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FunctionCallAction")
+            .field("method_name", &format_args!("{}", &self.method_name))
+            .field("args", &format_args!("{}", to_base58(&self.args)))
+            .field("gas", &format_args!("{}", &self.gas))
+            .field("deposit", &format_args!("{}", &self.deposit))
+            .finish()
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct TransferAction {
+    #[serde(with = "dec_format")]
+    pub deposit: Balance,
+}
+
+impl From<TransferAction> for Action {
+    fn from(transfer_action: TransferAction) -> Self {
+        Self::Transfer(transfer_action)
+    }
+}
+
+/// An action which stakes signer_id tokens and setup's validator public key
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct StakeAction {
+    /// Amount of tokens to stake.
+    #[serde(with = "dec_format")]
+    pub stake: Balance,
+    /// Validator key which will be used to sign transactions on behalf of signer_id
+    pub public_key: Ed25519PublicKey,
+}
+
+impl From<StakeAction> for Action {
+    fn from(stake_action: StakeAction) -> Self {
+        Self::Stake(stake_action)
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct AddKeyAction {
+    /// A public key which will be associated with an access_key
+    pub public_key: Ed25519PublicKey,
+    /// An access key with the permission
+    pub access_key: AccessKey,
+}
+
+impl From<AddKeyAction> for Action {
+    fn from(add_key_action: AddKeyAction) -> Self {
+        Self::AddKey(add_key_action)
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct DeleteKeyAction {
+    /// A public key associated with the access_key to be deleted.
+    pub public_key: Ed25519PublicKey,
+}
+
+impl From<DeleteKeyAction> for Action {
+    fn from(delete_key_action: DeleteKeyAction) -> Self {
+        Self::DeleteKey(delete_key_action)
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct DeleteAccountAction {
+    pub beneficiary_id: AccountId,
+}
+
+impl From<DeleteAccountAction> for Action {
+    fn from(delete_account_action: DeleteAccountAction) -> Self {
+        Self::DeleteAccount(delete_account_action)
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Eq, Debug, Clone)]
+#[borsh_init(init)]
+pub struct SignedTransaction {
+    pub transaction: Transaction,
+    pub signature: Ed25519Signature,
+    #[borsh_skip]
+    hash: CryptoHash,
+    #[borsh_skip]
+    size: u64,
+}
+
+impl SignedTransaction {
+    pub fn new(signature: Ed25519Signature, transaction: Transaction) -> Self {
+        let mut signed_tx = Self {
+            signature,
+            transaction,
+            hash: CryptoHash::default(),
+            size: u64::default(),
+        };
+        signed_tx.init();
+        signed_tx
+    }
+
+    pub fn init(&mut self) {
+        let (hash, size) = self.transaction.get_hash_and_size();
+        self.hash = hash;
+        self.size = size;
+    }
+
+    pub fn get_hash(&self) -> CryptoHash {
+        self.hash
+    }
+
+    pub fn get_size(&self) -> u64 {
+        self.size
+    }
+}
+
+impl Hash for SignedTransaction {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.hash.hash(state)
+    }
+}
+
+impl PartialEq for SignedTransaction {
+    fn eq(&self, other: &SignedTransaction) -> bool {
+        self.hash == other.hash && self.signature == other.signature
+    }
+}
+
+impl Borrow<CryptoHash> for SignedTransaction {
+    fn borrow(&self) -> &CryptoHash {
+        &self.hash
+    }
+}
+
+/// The status of execution for a transaction or a receipt.
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
+pub enum ExecutionStatus {
+    /// The execution is pending or unknown.
+    Unknown,
+    /// The execution has failed with the given execution error.
+    Failure(Box<TxExecutionError>),
+    /// The final action succeeded and returned some value or an empty vec.
+    SuccessValue(Vec<u8>),
+    /// The final action of the receipt returned a promise or the signed transaction was converted
+    /// to a receipt. Contains the receipt_id of the generated receipt.
+    SuccessReceiptId(CryptoHash),
+}
+
+impl fmt::Debug for ExecutionStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExecutionStatus::Unknown => f.write_str("Unknown"),
+            ExecutionStatus::Failure(e) => f.write_fmt(format_args!("Failure({})", e)),
+            ExecutionStatus::SuccessValue(v) => {
+                f.write_fmt(format_args!("SuccessValue({})", to_base58(v)))
+            }
+            ExecutionStatus::SuccessReceiptId(receipt_id) => {
+                f.write_fmt(format_args!("SuccessReceiptId({})", receipt_id))
+            }
+        }
+    }
+}
+
+impl Default for ExecutionStatus {
+    fn default() -> Self {
+        ExecutionStatus::Unknown
+    }
+}
+
+/// ExecutionOutcome for proof. Excludes logs and metadata
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
+pub struct PartialExecutionOutcome {
+    pub receipt_ids: Vec<CryptoHash>,
+    pub gas_burnt: Gas,
+    pub tokens_burnt: Balance,
+    pub executor_id: AccountId,
+    pub status: PartialExecutionStatus,
+}
+
+impl From<&ExecutionOutcome> for PartialExecutionOutcome {
+    fn from(outcome: &ExecutionOutcome) -> Self {
+        Self {
+            receipt_ids: outcome.receipt_ids.clone(),
+            gas_burnt: outcome.gas_burnt,
+            tokens_burnt: outcome.tokens_burnt,
+            executor_id: outcome.executor_id.clone(),
+            status: outcome.status.clone().into(),
+        }
+    }
+}
+
+/// ExecutionStatus for proof. Excludes failure debug info.
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
+pub enum PartialExecutionStatus {
+    Unknown,
+    Failure,
+    SuccessValue(Vec<u8>),
+    SuccessReceiptId(CryptoHash),
+}
+
+impl From<ExecutionStatus> for PartialExecutionStatus {
+    fn from(status: ExecutionStatus) -> PartialExecutionStatus {
+        match status {
+            ExecutionStatus::Unknown => PartialExecutionStatus::Unknown,
+            ExecutionStatus::Failure(_) => PartialExecutionStatus::Failure,
+            ExecutionStatus::SuccessValue(value) => PartialExecutionStatus::SuccessValue(value),
+            ExecutionStatus::SuccessReceiptId(id) => PartialExecutionStatus::SuccessReceiptId(id),
+        }
+    }
+}
+
+/// Execution outcome for one signed transaction or one receipt.
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Clone, Eq)]
+pub struct ExecutionOutcome {
+    /// Logs from this transaction or receipt.
+    pub logs: Vec<LogEntry>,
+    /// Receipt IDs generated by this transaction or receipt.
+    pub receipt_ids: Vec<CryptoHash>,
+    /// The amount of the gas burnt by the given transaction or receipt.
+    pub gas_burnt: Gas,
+    /// The amount of tokens burnt corresponding to the burnt gas amount.
+    /// This value doesn't always equal to the `gas_burnt` multiplied by the gas price, because
+    /// the prepaid gas price might be lower than the actual gas price and it creates a deficit.
+    pub tokens_burnt: Balance,
+    /// The id of the account on which the execution happens. For transaction this is signer_id,
+    /// for receipt this is receiver_id.
+    pub executor_id: AccountId,
+    /// Execution status. Contains the result in case of successful execution.
+    /// NOTE: Should be the latest field since it contains unparsable by light client
+    /// ExecutionStatus::Failure
+    pub status: ExecutionStatus,
+    /// Execution metadata, versioned
+    pub metadata: ExecutionMetadata,
+}
+
+impl Default for ExecutionOutcome {
+    fn default() -> Self {
+        Self {
+            logs: Default::default(),
+            receipt_ids: Default::default(),
+            gas_burnt: Default::default(),
+            tokens_burnt: Default::default(),
+            executor_id: AccountId::from_str("test").unwrap(),
+            status: Default::default(),
+            metadata: Default::default(),
+        }
+    }
+}
+
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Clone, Eq, Debug)]
+pub enum ExecutionMetadata {
+    // V1: Empty Metadata
+    V1,
+
+    // V2: With ProfileData
+    V2(ProfileData),
+}
+
+impl Default for ExecutionMetadata {
+    fn default() -> Self {
+        ExecutionMetadata::V1
+    }
+}
+
+impl fmt::Debug for ExecutionOutcome {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ExecutionOutcome")
+            .field("logs", &self.logs)
+            .field("receipt_ids", &self.receipt_ids)
+            .field("burnt_gas", &self.gas_burnt)
+            .field("tokens_burnt", &self.tokens_burnt)
+            .field("status", &self.status)
+            .field("metadata", &self.metadata)
+            .finish()
+    }
+}
+
+/// Execution outcome with the identifier.
+/// For a signed transaction, the ID is the hash of the transaction.
+/// For a receipt, the ID is the receipt ID.
+#[derive(PartialEq, Clone, Default, Debug, BorshSerialize, BorshDeserialize, Eq)]
+pub struct ExecutionOutcomeWithId {
+    /// The transaction hash or the receipt ID.
+    pub id: CryptoHash,
+    /// Should be the latest field since contains unparsable by light client ExecutionStatus::Failure
+    pub outcome: ExecutionOutcome,
+}

near-primitives-light/src/types.rs

@@ -0,0 +1,236 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use common_api::crypto::prelude::*;
+use near_primitives_core::{
+    account::{AccessKey, Account},
+    hash::CryptoHash,
+    serialize::dec_format,
+    types::*,
+};
+use serde::{Deserialize, Serialize};
+
+/// Hash used by to store state root.
+pub type StateRoot = CryptoHash;
+
+/// Different types of finality.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub enum Finality {
+    #[serde(rename = "optimistic")]
+    None,
+    #[serde(rename = "near-final")]
+    DoomSlug,
+    #[serde(rename = "final")]
+    Final,
+}
+
+impl Default for Finality {
+    fn default() -> Self {
+        Finality::Final
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AccountWithPublicKey {
+    pub account_id: AccountId,
+    pub public_key: Ed25519PublicKey,
+}
+
+/// Account info for validators
+#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
+pub struct AccountInfo {
+    pub account_id: AccountId,
+    pub public_key: Ed25519PublicKey,
+    #[serde(with = "dec_format")]
+    pub amount: Balance,
+}
+
+/// This type is used to mark function arguments.
+///
+/// NOTE: The main reason for this to exist (except the type-safety) is that the value is
+/// transparently serialized and deserialized as a base64-encoded string when serde is used
+/// (serde_json).
+#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
+pub struct FunctionArgs(Vec<u8>);
+
+/// A structure used to indicate the kind of state changes due to transaction/receipt processing, etc.
+#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+pub enum StateChangeKind {
+    AccountTouched { account_id: AccountId },
+    AccessKeyTouched { account_id: AccountId },
+    DataTouched { account_id: AccountId },
+    ContractCodeTouched { account_id: AccountId },
+}
+
+pub type StateChangesKinds = Vec<StateChangeKind>;
+
+/// A structure used to index state changes due to transaction/receipt processing and other things.
+#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+pub enum StateChangeCause {
+    /// A type of update that does not get finalized. Used for verification and execution of
+    /// immutable smart contract methods. Attempt fo finalize a `TrieUpdate` containing such
+    /// change will lead to panic.
+    NotWritableToDisk,
+    /// A type of update that is used to mark the initial storage update, e.g. during genesis
+    /// or in tests setup.
+    InitialState,
+    /// Processing of a transaction.
+    TransactionProcessing { tx_hash: CryptoHash },
+    /// Before the receipt is going to be processed, inputs get drained from the state, which
+    /// causes state modification.
+    ActionReceiptProcessingStarted { receipt_hash: CryptoHash },
+    /// Computation of gas reward.
+    ActionReceiptGasReward { receipt_hash: CryptoHash },
+    /// Processing of a receipt.
+    ReceiptProcessing { receipt_hash: CryptoHash },
+    /// The given receipt was postponed. This is either a data receipt or an action receipt.
+    /// A `DataReceipt` can be postponed if the corresponding `ActionReceipt` is not received yet,
+    /// or other data dependencies are not satisfied.
+    /// An `ActionReceipt` can be postponed if not all data dependencies are received.
+    PostponedReceipt { receipt_hash: CryptoHash },
+    /// Updated delayed receipts queue in the state.
+    /// We either processed previously delayed receipts or added more receipts to the delayed queue.
+    UpdatedDelayedReceipts,
+    /// State change that happens when we update validator accounts. Not associated with with any
+    /// specific transaction or receipt.
+    ValidatorAccountsUpdate,
+    /// State change that is happens due to migration that happens in first block of an epoch
+    /// after protocol upgrade
+    Migration,
+    /// State changes for building states for re-sharding
+    Resharding,
+}
+
+/// This represents the committed changes in the Trie with a change cause.
+#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+pub struct RawStateChange {
+    pub cause: StateChangeCause,
+    pub data: Option<Vec<u8>>,
+}
+
+#[derive(Debug)]
+pub enum StateChangesRequest {
+    AccountChanges { account_ids: Vec<AccountId> },
+    SingleAccessKeyChanges { keys: Vec<AccountWithPublicKey> },
+    AllAccessKeyChanges { account_ids: Vec<AccountId> },
+    ContractCodeChanges { account_ids: Vec<AccountId> },
+}
+
+#[derive(Debug)]
+pub enum StateChangeValue {
+    AccountUpdate {
+        account_id: AccountId,
+        account: Account,
+    },
+    AccountDeletion {
+        account_id: AccountId,
+    },
+    AccessKeyUpdate {
+        account_id: AccountId,
+        public_key: Ed25519PublicKey,
+        access_key: AccessKey,
+    },
+    AccessKeyDeletion {
+        account_id: AccountId,
+        public_key: Ed25519PublicKey,
+    },
+    ContractCodeUpdate {
+        account_id: AccountId,
+        code: Vec<u8>,
+    },
+    ContractCodeDeletion {
+        account_id: AccountId,
+    },
+}
+
+impl StateChangeValue {
+    pub fn affected_account_id(&self) -> &AccountId {
+        match &self {
+            StateChangeValue::AccountUpdate { account_id, .. }
+            | StateChangeValue::AccountDeletion { account_id }
+            | StateChangeValue::AccessKeyUpdate { account_id, .. }
+            | StateChangeValue::AccessKeyDeletion { account_id, .. }
+            | StateChangeValue::ContractCodeUpdate { account_id, .. }
+            | StateChangeValue::ContractCodeDeletion { account_id } => account_id,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct StateChangeWithCause {
+    pub cause: StateChangeCause,
+    pub value: StateChangeValue,
+}
+
+pub type StateChanges = Vec<StateChangeWithCause>;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum BlockId {
+    Height(BlockHeight),
+    Hash(CryptoHash),
+}
+
+pub type MaybeBlockId = Option<BlockId>;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum SyncCheckpoint {
+    Genesis,
+    EarliestAvailable,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum BlockReference {
+    BlockId(BlockId),
+    Finality(Finality),
+    SyncCheckpoint(SyncCheckpoint),
+}
+
+impl BlockReference {
+    pub fn latest() -> Self {
+        Self::Finality(Finality::None)
+    }
+}
+
+impl From<BlockId> for BlockReference {
+    fn from(block_id: BlockId) -> Self {
+        Self::BlockId(block_id)
+    }
+}
+
+impl From<Finality> for BlockReference {
+    fn from(finality: Finality) -> Self {
+        Self::Finality(finality)
+    }
+}
+
+#[derive(Default, BorshSerialize, BorshDeserialize, Clone, Debug, PartialEq, Eq)]
+pub struct ValidatorStats {
+    pub produced: NumBlocks,
+    pub expected: NumBlocks,
+}
+
+#[derive(Debug, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
+pub struct BlockChunkValidatorStats {
+    pub block_stats: ValidatorStats,
+    pub chunk_stats: ValidatorStats,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum TransactionOrReceiptId {
+    Transaction {
+        transaction_hash: CryptoHash,
+        sender_id: AccountId,
+    },
+    Receipt {
+        receipt_id: CryptoHash,
+        receiver_id: AccountId,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize)]
+pub enum CompiledContract {
+    CompileModuleError,
+    Code(Vec<u8>),
+}

near-rpc/Cargo.toml

@@ -13,9 +13,8 @@ bs58 = "0.4"
 borsh = "0.9"
 common-api = { path = "../common-api" }
 itertools = "0.10"
-near-account-id = "0.15"
-near-primitives = "0.15"
-near-crypto = "0.15"
+near-primitives-light = { path = "../near-primitives-light" }
+near-primitives-core = "0.15"
 near-units = "0.2"
 reqwest = { version = "0.11", features = ["json"] }
 serde = { version = "1", default-features = false, features = ["derive"] }
@@ -30,4 +29,6 @@ rand = "0.8.5"
 rand_chacha = "0.3"
 tempfile = "3"
 tokio = { version = "1.2.1", features = ["full"] }
-workspaces = { git = "https://github.com/near/workspaces-rs.git", features = ["unstable"] }
+workspaces = { git = "https://github.com/near/workspaces-rs.git", features = [
+    "unstable",
+] }

near-rpc/src/client.rs

@@ -1,19 +1,22 @@
-use near_primitives::{
-    account::{id::AccountId, AccessKey, AccessKeyPermission},
-    hash::CryptoHash,
+use near_primitives_light::{
     transaction::{
         Action, AddKeyAction, CreateAccountAction, DeleteAccountAction, DeployContractAction,
         FunctionCallAction, TransferAction,
     },
-    types::{Balance, Finality, Gas, Nonce},
+    types::Finality,
     views::{BlockView, FinalExecutionOutcomeView, FinalExecutionStatus},
 };
 
+use near_primitives_core::{
+    account::{id::AccountId, AccessKey, AccessKeyPermission},
+    hash::CryptoHash,
+    types::{Balance, Gas, Nonce},
+};
+
 use crate::{
     rpc::client::RpcClient,
     utils::{
-        serialize_arguments, serialize_transaction, to_public_key, TransactionInfo, ViewAccessKey,
-        ViewResult,
+        serialize_arguments, serialize_transaction, TransactionInfo, ViewAccessKey, ViewResult,
     },
     Error, Result,
 };
@@ -262,7 +265,7 @@ impl NearClient {
         let actions = vec![
             CreateAccountAction {}.into(),
             AddKeyAction {
-                public_key: to_public_key(new_account_pk),
+                public_key: new_account_pk,
                 access_key: AccessKey {
                     nonce: 0,
                     permission: AccessKeyPermission::FullAccess,

near-rpc/src/lib.rs

@@ -12,7 +12,7 @@ pub enum Error {
     #[error("Transaction not started")]
     TxNotStarted,
     #[error("Transaction failed during execution, cause [\"{0:?}\"]")]
-    TxExecution(near_primitives::errors::TxExecutionError),
+    TxExecution(near_primitives_light::errors::TxExecutionError),
     #[error("Transaction serialization error: [\"{0}\"]")]
     TxSerialization(std::io::Error),
     #[error("Couldn't serialize an argument [\"{0}\"] to view a transaction, cause: [\"{1}\"]")]

near-rpc/src/utils.rs

@@ -4,13 +4,15 @@ use crate::{
     Error, Result,
 };
 
-use common_api::crypto::prelude::*;
-use near_account_id::AccountId;
-use near_crypto::{ED25519PublicKey, KeyType, PublicKey, Signature};
-use near_primitives::{
+// use common_api::crypto::prelude::*;
+use near_primitives_core::{
+    account::id::AccountId,
     hash::CryptoHash,
+    types::{BlockHeight, Nonce},
+};
+use near_primitives_light::{
     transaction::{Action, SignedTransaction, Transaction},
-    types::{BlockHeight, Finality, Nonce},
+    types::Finality,
     views::{AccessKeyPermissionView, AccessKeyView},
 };
 use serde::{
@@ -87,7 +89,7 @@ pub(crate) async fn serialize_transaction<'a>(
 
     let transaction = Transaction {
         signer_id: info.signer.account().clone(),
-        public_key: to_public_key(*info.signer.public_key()),
+        public_key: *info.signer.public_key(),
         nonce: info.signer.nonce() + 1,
         receiver_id: info.contract_id.clone(),
         block_hash,
@@ -110,17 +112,17 @@ pub(crate) fn serialize_arguments(args: Option<Value>) -> Result<Vec<u8>> {
 pub(crate) fn sign_transaction(signer: &Signer, transaction: Transaction) -> SignedTransaction {
     let (hash, ..) = transaction.get_hash_and_size();
     let signature = signer.sign(hash.0.as_ref());
-    SignedTransaction::new(to_signature(signature), transaction)
+    SignedTransaction::new(signature, transaction)
 }
 
-pub(crate) fn to_public_key(pk: Ed25519PublicKey) -> PublicKey {
-    PublicKey::ED25519(ED25519PublicKey(pk.to_bytes()))
-}
+// pub(crate) fn to_public_key(pk: Ed25519PublicKey) -> PublicKey {
+//     PublicKey::ED25519(ED25519PublicKey(pk.to_bytes()))
+// }
 
-pub(crate) fn to_signature(signature: Ed25519Signature) -> Signature {
-    // Panic is impossible
-    Signature::from_parts(KeyType::ED25519, &signature.to_bytes()).unwrap()
-}
+// pub(crate) fn to_signature(signature: Ed25519Signature) -> Signature {
+//     // Panic is impossible
+//     Signature::from_parts(KeyType::ED25519, &signature.to_bytes()).unwrap()
+// }
 
 impl<'de> Deserialize<'de> for ViewAccessKey {
     fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>

near-rpc/tests/rpc.rs

@@ -1,6 +1,6 @@
 use common_api::crypto::prelude::*;
 use git2::{Cred, RemoteCallbacks};
-use near_primitives::{types::Finality, views::AccessKeyView};
+use near_primitives_light::{types::Finality, views::AccessKeyView};
 use near_rpc::{
     client::{NearClient, Signer},
     utils::{ViewAccessKey, ViewAccessKeyResult},

web-client/Cargo.toml

@@ -19,8 +19,8 @@ futures = "0.3"
 gloo-timers = { version = "0.2.4", features = ["futures-core", "futures"] }
 itertools = "0.10"
 js-sys = "0.3"
-near-account-id = "0.15.0"
-near-primitives = "0.15"
+near-primitives-light = { path = "../near-primitives-light" }
+near-primitives-core = "0.15"
 near-units = "0.2"
 near-rpc = { path = "../near-rpc" }
 rand = { version = "0.8.5" }

web-client/src/errors.rs

@@ -1,4 +1,4 @@
-use near_account_id::ParseAccountError;
+use near_primitives_core::account::id::ParseAccountError;
 use near_rpc::Error;
 use wasm_bindgen::convert::{FromWasmAbi, IntoWasmAbi};
 use wasm_bindgen::prelude::*;

web-client/src/lib.rs

@@ -4,16 +4,15 @@ use aes_gcm::{
 };
 use futures::{lock::Mutex, select, FutureExt};
 use itertools::Itertools;
-use near_account_id::AccountId;
 use rand::{RngCore, SeedableRng};
 use serde_json::json;
 use wasm_bindgen::prelude::*;
 
-use near_primitives::types::Finality;
+use near_primitives_core::{account::id::AccountId, types::Nonce};
+use near_primitives_light::types::Finality;
 use near_rpc::client::{NearClient, Signer};
 
 use js_sys::Promise;
-use near_primitives::types::Nonce;
 
 use std::{ops::DerefMut, str::FromStr, sync::Arc};
 
@@ -23,10 +22,7 @@ use blake2::{
 };
 
 pub mod errors;
-use common_api::crypto::{
-    key_exchange::{PublicKey, SecretKey},
-    Key as _,
-};
+use common_api::crypto::prelude::*;
 
 use errors::{ApiError, ErrorType};
 use gloo_timers::future::TimeoutFuture;

web-client/tests/integration.rs

@@ -1,8 +1,6 @@
 use common_api::crypto::prelude::*;
-use near_primitives::{
-    account::id::AccountId,
-    types::{Balance, Finality},
-};
+use near_primitives_core::{account::id::AccountId, types::Balance};
+use near_primitives_light::types::Finality;
 use near_rpc::client::{NearClient, Signer};
 use rand::{RngCore, SeedableRng};
 use rand_chacha::ChaChaRng;