feat: draft implementation of NEP-366

chain/rosetta-rpc/src/adapters/mod.rs

@@ -410,6 +410,7 @@ impl From<NearActions> for Vec<crate::models::Operation> {
                     );
                     operations.push(deploy_contract_operation);
                 }
+                near_primitives::transaction::Action::Delegate(_) => todo!(),
             }
         }
         operations

core/primitives-core/src/parameter.rs

@@ -79,6 +79,9 @@ pub enum Parameter {
     ActionDeleteKeySendSir,
     ActionDeleteKeySendNotSir,
     ActionDeleteKeyExecution,
+    ActionDelegateSendSir,
+    ActionDelegateSendNotSir,
+    ActionDelegateExecution,
 
     // Smart contract dynamic gas costs
     WasmRegularOpCost,
@@ -203,6 +206,7 @@ pub enum FeeParameter {
     ActionAddFunctionCallKey,
     ActionAddFunctionCallKeyPerByte,
     ActionDeleteKey,
+    ActionDelegate,
 }
 
 impl Parameter {

core/primitives-core/src/runtime/fees.rs

@@ -113,6 +113,9 @@ pub struct ActionCreationConfig {
 
     /// Base cost of deleting an account.
     pub delete_account_cost: Fee,
+
+    /// Base cost of a delegate action
+    pub delegate_cost: Fee,
 }
 
 /// Describes the cost of creating an access key.
@@ -219,6 +222,11 @@ impl RuntimeFeesConfig {
                     send_not_sir: 147489000000,
                     execution: 147489000000,
                 },
+                delegate_cost: Fee {
+                    send_sir: 2319861500000,
+                    send_not_sir: 2319861500000,
+                    execution: 2319861500000,
+                },
             },
             storage_usage_config: StorageUsageConfig {
                 // See Account in core/primitives/src/account.rs for the data structure.
@@ -253,7 +261,8 @@ impl RuntimeFeesConfig {
                     function_call_cost_per_byte: free.clone(),
                 },
                 delete_key_cost: free.clone(),
-                delete_account_cost: free,
+                delete_account_cost: free.clone(),
+                delegate_cost: free,
             },
             storage_usage_config: StorageUsageConfig {
                 num_bytes_account: 0,

core/primitives/res/runtime_configs/parameters.txt

@@ -66,6 +66,9 @@ action_add_function_call_key_per_byte_execution: 1_925_331
 action_delete_key_send_sir: 94_946_625_000
 action_delete_key_send_not_sir: 94_946_625_000
 action_delete_key_execution: 94_946_625_000
+action_delegate_send_sir: 2_319_861_500_000
+action_delegate_send_not_sir: 2_319_861_500_000
+action_delegate_execution: 2_319_861_500_000
 
 # Smart contract dynamic gas costs
 wasm_regular_op_cost: 3_856_371

core/primitives/res/runtime_configs/parameters_testnet.txt

@@ -62,6 +62,9 @@ action_add_function_call_key_per_byte_execution: 1_925_331
 action_delete_key_send_sir: 94_946_625_000
 action_delete_key_send_not_sir: 94_946_625_000
 action_delete_key_execution: 94_946_625_000
+action_delegate_send_sir: 2_319_861_500_000
+action_delegate_send_not_sir: 2_319_861_500_000
+action_delegate_execution: 2_319_861_500_000
 
 # Smart contract dynamic gas costs
 wasm_regular_op_cost: 3_856_371

core/primitives/src/errors.rs

@@ -200,6 +200,12 @@ pub enum ActionsValidationError {
     UnsuitableStakingKey { public_key: PublicKey },
     /// The attached amount of gas in a FunctionCall action has to be a positive number.
     FunctionCallZeroAttachedGas,
+    /// The actions in DelegateAction are searilized incorrectly
+    DelegateActionDeserializeError,
+    /// DelegateAction actions contain another DelegateAction
+    DelegateActionCantContainNestedOne,
+    /// There should be the only one DelegateAction
+    DelegateActionMustBeOnlyOne,
 }
 
 /// Describes the error for validating a receipt.
@@ -317,6 +323,18 @@ impl Display for ActionsValidationError {
                 f,
                 "The attached amount of gas in a FunctionCall action has to be a positive number",
             ),
+            ActionsValidationError::DelegateActionDeserializeError => write!(
+                f,
+                "Can't deserialize actions in DelegateAction"
+            ),
+            ActionsValidationError::DelegateActionCantContainNestedOne => write!(
+                f,
+                "DelegateAction must not contain another DelegateAction"
+            ),
+            ActionsValidationError::DelegateActionMustBeOnlyOne => write!(
+                f,
+                "The actions can contain the ony one DelegateAction"
+            )
         }
     }
 }
@@ -441,6 +459,20 @@ pub enum ActionErrorKind {
     OnlyImplicitAccountCreationAllowed { account_id: AccountId },
     /// Delete account whose state is large is temporarily banned.
     DeleteAccountWithLargeState { account_id: AccountId },
+    /// Signature does not match the provided actions and given signer public key.
+    DelegateActionInvalidSignature,
+    /// Receiver of the transaction doesn't match Sender of the delegate action
+    DelegateActionSenderDoesNotMatchTxReceiver { sender_id: AccountId, receiver_id: AccountId },
+    /// Sender account doesn't exist
+    DelegateActionSenderDoesNotExist { sender_id: AccountId },
+    /// Delegate action has expired. `max_block_height` is less than actual block height.
+    DelegateActionExpired,
+    /// The given public key doesn't exist for Sender account
+    DelegateActionAccessKeyError(InvalidAccessKeyError),
+    /// DelegateAction nonce must be greater sender[public_key].nonce
+    DelegateActionInvalidNonce { delegate_nonce: Nonce, ak_nonce: Nonce },
+    /// DelegateAction nonce is larger than the upper bound given by the block height
+    DelegateActionNonceTooLarge { delegate_nonce: Nonce, upper_bound: Nonce },
 }
 
 impl From<ActionErrorKind> for ActionError {
@@ -751,6 +783,13 @@ impl Display for ActionErrorKind {
             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),
+            ActionErrorKind::DelegateActionInvalidSignature => write!(f, "DelegateAction is not signed with the given public key"),
+            ActionErrorKind::DelegateActionSenderDoesNotMatchTxReceiver { sender_id, receiver_id } => write!(f, "Transaction reciever {} doesn't match DelegateAction sender {}", sender_id, receiver_id),
+            ActionErrorKind::DelegateActionSenderDoesNotExist { sender_id } => write!(f, "DelegateAction sender account {} doesn't exist", sender_id),
+            ActionErrorKind::DelegateActionExpired => write!(f, "DelegateAction has expired"),
+            ActionErrorKind::DelegateActionAccessKeyError(access_key_error) => Display::fmt(&access_key_error, f),
+            ActionErrorKind::DelegateActionInvalidNonce { delegate_nonce, ak_nonce } => write!(f, "DelegateAction nonce {} must be larger than nonce of the used access key {}", delegate_nonce, ak_nonce),
+            ActionErrorKind::DelegateActionNonceTooLarge { delegate_nonce, upper_bound } => write!(f, "DelegateAction nonce {} must be smaller than the access key nonce upper bound {}", delegate_nonce, upper_bound),
         }
     }
 }

core/primitives/src/receipt.rs

@@ -87,6 +87,30 @@ impl Receipt {
             }),
         }
     }
+
+    pub fn new_delegate_actions(
+        signer_id: &AccountId,
+        predecessor_id: &AccountId,
+        receiver_id: &AccountId,
+        actions: &Vec<Action>,
+        public_key: &PublicKey,
+        gas_price: Balance,
+    ) -> Self {
+        Receipt {
+            predecessor_id: predecessor_id.clone(),
+            receiver_id: receiver_id.clone(),
+            receipt_id: CryptoHash::default(),
+
+            receipt: ReceiptEnum::Action(ActionReceipt {
+                signer_id: signer_id.clone(),
+                signer_public_key: public_key.clone(),
+                gas_price: gas_price,
+                output_data_receivers: vec![],
+                input_data_ids: vec![],
+                actions: actions.clone(),
+            }),
+        }
+    }
 }
 
 /// Receipt could be either ActionReceipt or DataReceipt

core/primitives/src/runtime/parameter_table.rs

@@ -125,6 +125,7 @@ impl ParameterTable {
                 },
                 "delete_key_cost": self.fee_json(FeeParameter::ActionDeleteKey),
                 "delete_account_cost": self.fee_json(FeeParameter::ActionDeleteAccount),
+                "delegate_cost": self.fee_json(FeeParameter::ActionDelegate),
             },
             "storage_usage_config": {
                 "num_bytes_account": self.get(Parameter::StorageNumBytesAccount),

core/primitives/src/transaction.rs

@@ -1,8 +1,10 @@
 use std::borrow::Borrow;
 use std::fmt;
 use std::hash::{Hash, Hasher};
+use std::io::{Error, ErrorKind};
 
 use borsh::{BorshDeserialize, BorshSerialize};
+use near_primitives_core::types::BlockHeight;
 use serde::{Deserialize, Serialize};
 
 use near_crypto::{PublicKey, Signature};
@@ -70,6 +72,7 @@ pub enum Action {
     AddKey(AddKeyAction),
     DeleteKey(DeleteKeyAction),
     DeleteAccount(DeleteAccountAction),
+    Delegate(SignedDelegateAction),
 }
 
 impl Action {
@@ -220,6 +223,81 @@ impl From<DeleteAccountAction> for Action {
     }
 }
 
+#[cfg_attr(feature = "deepsize_feature", derive(deepsize::DeepSizeOf))]
+#[derive(Serialize, BorshSerialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct NonDelegateAction(Action);
+
+const ACTION_DELEGATE_NUMBER: u8 = 8;
+
+impl From<&NonDelegateAction> for Action {
+    fn from(action: &NonDelegateAction) -> Self {
+        action.0.clone()
+    }
+}
+
+impl borsh::de::BorshDeserialize for NonDelegateAction {
+    fn deserialize(buf: &mut &[u8]) -> ::core::result::Result<Self, borsh::maybestd::io::Error> {
+        match buf[0] {
+            ACTION_DELEGATE_NUMBER => Err(Error::new(
+                ErrorKind::InvalidInput,
+                "DelegateAction mustn't contain a nested one",
+            )),
+            _ => Ok(Self(borsh::BorshDeserialize::deserialize(buf)?)),
+        }
+    }
+}
+
+#[cfg_attr(feature = "deepsize_feature", derive(deepsize::DeepSizeOf))]
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct DelegateAction {
+    /// Signer of the delegated actions
+    pub sender_id: AccountId,
+    /// Receiver of the delegated actions.
+    pub receiver_id: AccountId,
+    /// List of actions to be executed.
+    pub actions: Vec<NonDelegateAction>,
+    /// Nonce to ensure that the same delegate action is not sent twice by a relayer and should match for given account's `public_key`.
+    /// After this action is processed it will increment.
+    pub nonce: Nonce,
+    /// The maximal height of the block in the blockchain below which the given DelegateAction is valid.
+    pub max_block_height: BlockHeight,
+    /// Public key that is used to sign this delegated action.
+    pub public_key: PublicKey,
+}
+#[cfg_attr(feature = "deepsize_feature", derive(deepsize::DeepSizeOf))]
+#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct SignedDelegateAction {
+    pub delegate_action: DelegateAction,
+    pub signature: Signature,
+}
+
+impl SignedDelegateAction {
+    pub fn verify(&self) -> bool {
+        let delegate_action = &self.delegate_action;
+        let hash = delegate_action.get_hash();
+        let public_key = &delegate_action.public_key;
+
+        self.signature.verify(hash.as_ref(), public_key)
+    }
+}
+
+impl From<SignedDelegateAction> for Action {
+    fn from(delegate_action: SignedDelegateAction) -> Self {
+        Self::Delegate(delegate_action)
+    }
+}
+
+impl DelegateAction {
+    pub fn get_actions(&self) -> Vec<Action> {
+        self.actions.iter().map(|a| a.into()).collect()
+    }
+
+    pub fn get_hash(&self) -> CryptoHash {
+        let bytes = self.try_to_vec().expect("Failed to deserialize");
+        hash(&bytes)
+    }
+}
+
 #[cfg_attr(feature = "deepsize_feature", derive(deepsize::DeepSizeOf))]
 #[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Eq, Debug, Clone)]
 #[borsh_init(init)]

core/primitives/src/views.rs

@@ -32,9 +32,10 @@ use crate::sharding::{
     ShardChunkHeaderV3,
 };
 use crate::transaction::{
-    Action, AddKeyAction, CreateAccountAction, DeleteAccountAction, DeleteKeyAction,
-    DeployContractAction, ExecutionMetadata, ExecutionOutcome, ExecutionOutcomeWithIdAndProof,
-    ExecutionStatus, FunctionCallAction, SignedTransaction, StakeAction, TransferAction,
+    Action, AddKeyAction, CreateAccountAction, DelegateAction, DeleteAccountAction,
+    DeleteKeyAction, DeployContractAction, ExecutionMetadata, ExecutionOutcome,
+    ExecutionOutcomeWithIdAndProof, ExecutionStatus, FunctionCallAction, SignedDelegateAction,
+    SignedTransaction, StakeAction, TransferAction,
 };
 use crate::types::{
     AccountId, AccountWithPublicKey, Balance, BlockHeight, CompiledContractCache, EpochHeight,
@@ -954,6 +955,10 @@ pub enum ActionView {
     DeleteAccount {
         beneficiary_id: AccountId,
     },
+    Delegate {
+        delegate_action: DelegateAction,
+        signature: Signature,
+    },
 }
 
 impl From<Action> for ActionView {
@@ -982,6 +987,10 @@ impl From<Action> for ActionView {
             Action::DeleteAccount(action) => {
                 ActionView::DeleteAccount { beneficiary_id: action.beneficiary_id }
             }
+            Action::Delegate(action) => ActionView::Delegate {
+                delegate_action: action.delegate_action,
+                signature: action.signature,
+            },
         }
     }
 }
@@ -1011,6 +1020,12 @@ impl TryFrom<ActionView> for Action {
             ActionView::DeleteAccount { beneficiary_id } => {
                 Action::DeleteAccount(DeleteAccountAction { beneficiary_id })
             }
+            ActionView::Delegate { delegate_action, signature } => {
+                Action::Delegate(SignedDelegateAction {
+                    delegate_action: delegate_action,
+                    signature,
+                })
+            }
         })
     }
 }

runtime/runtime-params-estimator/src/cost.rs

@@ -154,6 +154,9 @@ pub enum Cost {
     /// Subtract the base cost of creating a sir-receipt.
     /// (TODO[jakmeier] Consider different account states.
     ActionDeleteAccount,
+    /// Estimates `action_creation_config.delegate_cost` which is charged
+    /// for `DelegateAction` actions.
+    ActionDelegate,
 
     /// Estimates `wasm_config.ext_costs.base` which is intended to be charged
     /// once on every host function call. However, this is currently

runtime/runtime-params-estimator/src/costs_to_runtime_config.rs

@@ -78,6 +78,7 @@ fn runtime_fees_config(cost_table: &CostTable) -> anyhow::Result<RuntimeFeesConf
             },
             delete_key_cost: fee(Cost::ActionDeleteKey)?,
             delete_account_cost: fee(Cost::ActionDeleteAccount)?,
+            delegate_cost: fee(Cost::ActionDelegate)?,
         },
         ..actual_fees_config.clone()
     };