Struct sui_core::authority::AuthorityState

pub struct AuthorityState {
    pub name: AuthorityName,
    pub secret: StableSyncAuthoritySigner,
    pub indexes: Option<Arc<IndexStore>>,
    pub subscription_handler: Arc<SubscriptionHandler>,
    pub metrics: Arc<AuthorityMetrics>,
    pub overload_info: AuthorityOverloadInfo,
    /* private fields */
}

Fields

name: AuthorityName

The name of this authority.

secret: StableSyncAuthoritySigner

The signature key of the authority.

indexes: Option<Arc<IndexStore>>

subscription_handler: Arc<SubscriptionHandler>

metrics: Arc<AuthorityMetrics>

overload_info: AuthorityOverloadInfo

Current overload status in this authority. Updated periodically.

Implementations

impl AuthorityState

The authority state encapsulates all state, drives execution, and ensures safety.

Note the authority operations can be accessed through a read ref (&) and do not require &mut. Internally a database is synchronized through a mutex lock.

Repeating valid commands should produce no changes and return no error.

pub fn is_validator(&self, epoch_store: &AuthorityPerEpochStore) -> bool

pub fn is_fullnode(&self, epoch_store: &AuthorityPerEpochStore) -> bool

pub fn committee_store(&self) -> &Arc<CommitteeStore>

pub fn clone_committee_store(&self) -> Arc<CommitteeStore>

pub fn overload_config(&self) -> &AuthorityOverloadConfig

pub fn get_epoch_state_commitments( &self, epoch: EpochId ) -> SuiResult<Option<Vec<CheckpointCommitment>>>

pub async fn handle_transaction( &self, epoch_store: &Arc<AuthorityPerEpochStore>, transaction: VerifiedTransaction ) -> SuiResult<HandleTransactionResponse>

Initiate a new transaction.

pub fn check_system_overload_at_signing(&self) -> bool

pub fn check_system_overload_at_execution(&self) -> bool

pub async fn fullnode_execute_certificate_with_effects( &self, transaction: &VerifiedExecutableTransaction, effects: &VerifiedCertifiedTransactionEffects, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult

Executes a transaction that’s known to have correct effects. For such transaction, we don’t have to wait for consensus to set shared object locks because we already know the shared object versions based on the effects. This function can be called by a fullnode only.

pub async fn execute_certificate( &self, certificate: &VerifiedCertificate, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult<VerifiedSignedTransactionEffects>

Executes a certificate for its effects.

pub async fn try_execute_immediately( &self, certificate: &VerifiedExecutableTransaction, expected_effects_digest: Option<TransactionEffectsDigest>, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult<(TransactionEffects, Option<ExecutionError>)>

Internal logic to execute a certificate.

Guarantees that

• If input objects are available, return no permanent failure.
• Execution and output commit are atomic. i.e. outputs are only written to storage, on successful execution; crashed execution has no observable effect and can be retried.

It is caller’s responsibility to ensure input objects are available and locks are set. If this cannot be satisfied by the caller, execute_certificate() should be called instead.

Should only be called within sui-core.

pub async fn read_objects_for_execution( &self, certificate: &VerifiedExecutableTransaction, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult<InputObjects>

pub async fn try_execute_for_test( &self, certificate: &VerifiedCertificate ) -> SuiResult<(VerifiedSignedTransactionEffects, Option<ExecutionError>)>

Test only wrapper for try_execute_immediately() above, useful for checking errors if the pre-conditions are not satisfied, and executing change epoch transactions.

pub async fn notify_read_effects( &self, certificate: &VerifiedCertificate ) -> SuiResult<TransactionEffects>

pub fn prepare_certificate_for_benchmark( &self, certificate: &VerifiedExecutableTransaction, input_objects: InputObjects, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult<(InnerTemporaryStore, TransactionEffects, Option<ExecutionError>)>

pub async fn dry_exec_transaction( &self, transaction: TransactionData, transaction_digest: TransactionDigest ) -> SuiResult<(DryRunTransactionBlockResponse, BTreeMap<ObjectID, (ObjectRef, Object, WriteKind)>, TransactionEffects, Option<ObjectID>)>

pub async fn dry_exec_transaction_for_benchmark( &self, transaction: TransactionData, transaction_digest: TransactionDigest ) -> SuiResult<(DryRunTransactionBlockResponse, BTreeMap<ObjectID, (ObjectRef, Object, WriteKind)>, TransactionEffects, Option<ObjectID>)>

pub async fn dev_inspect_transaction_block( &self, sender: SuiAddress, transaction_kind: TransactionKind, gas_price: Option<u64>, gas_budget: Option<u64>, gas_sponsor: Option<SuiAddress>, gas_objects: Option<Vec<ObjectRef>>, show_raw_txn_data_and_effects: Option<bool>, skip_checks: Option<bool> ) -> SuiResult<DevInspectResults>

The object ID for gas can be any object ID, even for an uncreated object

pub fn reference_gas_price_for_testing(&self) -> Result<u64, Error>

pub fn is_tx_already_executed( &self, digest: &TransactionDigest ) -> SuiResult<bool>

pub fn unixtime_now_ms() -> u64

pub async fn handle_transaction_info_request( &self, request: TransactionInfoRequest ) -> SuiResult<TransactionInfoResponse>

pub async fn handle_object_info_request( &self, request: ObjectInfoRequest ) -> SuiResult<ObjectInfoResponse>

pub fn handle_checkpoint_request( &self, request: &CheckpointRequest ) -> SuiResult<CheckpointResponse>

pub fn handle_checkpoint_request_v2( &self, request: &CheckpointRequestV2 ) -> SuiResult<CheckpointResponseV2>

pub async fn new( name: AuthorityName, secret: StableSyncAuthoritySigner, supported_protocol_versions: SupportedProtocolVersions, store: Arc<AuthorityStore>, execution_cache: Arc<ExecutionCache>, epoch_store: Arc<AuthorityPerEpochStore>, committee_store: Arc<CommitteeStore>, indexes: Option<Arc<IndexStore>>, checkpoint_store: Arc<CheckpointStore>, prometheus_registry: &Registry, genesis_objects: &[Object], db_checkpoint_config: &DBCheckpointConfig, config: NodeConfig, indirect_objects_threshold: usize, archive_readers: ArchiveReaderBalancer ) -> Arc<Self>

pub fn get_execution_cache(&self) -> Arc<ExecutionCache>

pub fn get_cache_reader(&self) -> &Arc<dyn ExecutionCacheRead>

pub fn get_backing_store(&self) -> &Arc<dyn BackingStore + Send + Sync>

pub fn get_backing_package_store( &self ) -> &Arc<dyn BackingPackageStore + Send + Sync>

pub fn get_effects_notify_read(&self) -> &NotifyReadWrapper<ExecutionCache>

pub fn get_object_store(&self) -> &Arc<dyn ObjectStore + Send + Sync>

pub fn get_reconfig_api(&self) -> &Arc<dyn ExecutionCacheReconfigAPI>

pub fn get_accumulator_store(&self) -> &Arc<dyn AccumulatorStore>

pub fn get_checkpoint_cache(&self) -> &Arc<dyn CheckpointCache>

pub fn get_state_sync_store(&self) -> &Arc<dyn StateSyncAPI>

pub fn get_cache_commit(&self) -> &Arc<dyn ExecutionCacheCommit>

pub fn database_for_testing(&self) -> &Arc<AuthorityStore>

pub async fn prune_checkpoints_for_eligible_epochs_for_testing( &self, config: NodeConfig, metrics: Arc<AuthorityStorePruningMetrics> ) -> Result<()>

pub fn transaction_manager(&self) -> &Arc<TransactionManager>

pub fn enqueue_certificates_for_execution( &self, certs: Vec<VerifiedCertificate>, epoch_store: &Arc<AuthorityPerEpochStore> )

Adds certificates to transaction manager for ordered execution. It is unnecessary to persist the certificates into the pending_execution table, because only Narwhal output needs to be persisted.

pub async fn execution_lock_for_executable_transaction( &self, transaction: &VerifiedExecutableTransaction ) -> SuiResult<RwLockReadGuard<'_, EpochId>>

Attempts to acquire execution lock for an executable transaction. Returns the lock if the transaction is matching current executed epoch Returns None otherwise

pub async fn execution_lock_for_reconfiguration( &self ) -> RwLockWriteGuard<'_, EpochId>

pub async fn reconfigure( &self, cur_epoch_store: &AuthorityPerEpochStore, supported_protocol_versions: SupportedProtocolVersions, new_committee: Committee, epoch_start_configuration: EpochStartConfiguration, checkpoint_executor: &CheckpointExecutor, accumulator: Arc<StateAccumulator>, expensive_safety_check_config: &ExpensiveSafetyCheckConfig ) -> SuiResult<Arc<AuthorityPerEpochStore>>

pub fn current_epoch_for_testing(&self) -> EpochId

pub fn checkpoint_all_dbs( &self, checkpoint_path: &Path, cur_epoch_store: &AuthorityPerEpochStore, checkpoint_indexes: bool ) -> SuiResult

pub fn load_epoch_store_one_call_per_task( &self ) -> Guard<Arc<AuthorityPerEpochStore>>

Load the current epoch store. This can change during reconfiguration. To ensure that we never end up accessing different epoch stores in a single task, we need to make sure that this is called once per task. Each call needs to be carefully audited to ensure it is the case. This also means we should minimize the number of call-sites. Only call it when there is no way to obtain it from somewhere else.

pub fn epoch_store_for_testing(&self) -> Guard<Arc<AuthorityPerEpochStore>>

pub fn clone_committee_for_testing(&self) -> Committee

pub async fn get_object( &self, object_id: &ObjectID ) -> SuiResult<Option<Object>>

pub async fn get_sui_system_package_object_ref(&self) -> SuiResult<ObjectRef>

pub fn get_sui_system_state_object_for_testing( &self ) -> SuiResult<SuiSystemState>

pub fn get_checkpoint_by_sequence_number( &self, sequence_number: CheckpointSequenceNumber ) -> SuiResult<Option<VerifiedCheckpoint>>

pub fn get_transaction_checkpoint_for_tests( &self, digest: &TransactionDigest, epoch_store: &AuthorityPerEpochStore ) -> SuiResult<Option<VerifiedCheckpoint>>

pub fn get_object_read(&self, object_id: &ObjectID) -> SuiResult<ObjectRead>

pub fn get_chain_identifier(&self) -> Option<ChainIdentifier>

Chain Identifier is the digest of the genesis checkpoint.

pub fn get_move_object<T>(&self, object_id: &ObjectID) -> SuiResult<T>

where T: DeserializeOwned,

pub fn get_past_object_read( &self, object_id: &ObjectID, version: SequenceNumber ) -> SuiResult<PastObjectRead>

This function aims to serve rpc reads on past objects and we don’t expect it to be called for other purposes. Depending on the object pruning policies that will be enforced in the future there is no software-level guarantee/SLA to retrieve an object with an old version even if it exists/existed.

pub fn get_owner_objects( &self, owner: SuiAddress, cursor: Option<ObjectID>, limit: usize, filter: Option<SuiObjectDataFilter> ) -> SuiResult<Vec<ObjectInfo>>

pub fn get_owned_coins_iterator_with_cursor( &self, owner: SuiAddress, cursor: (String, ObjectID), limit: usize, one_coin_type_only: bool ) -> SuiResult<impl Iterator<Item = (String, ObjectID, CoinInfo)> + '_>

pub fn get_owner_objects_iterator( &self, owner: SuiAddress, cursor: Option<ObjectID>, filter: Option<SuiObjectDataFilter> ) -> SuiResult<impl Iterator<Item = ObjectInfo> + '_>

pub async fn get_move_objects<T>( &self, owner: SuiAddress, type_: MoveObjectType ) -> SuiResult<Vec<T>>

where T: DeserializeOwned,

pub fn get_dynamic_fields( &self, owner: ObjectID, cursor: Option<ObjectID>, limit: usize ) -> SuiResult<Vec<(ObjectID, DynamicFieldInfo)>>

pub fn get_dynamic_field_object_id( &self, owner: ObjectID, name_type: TypeTag, name_bcs_bytes: &[u8] ) -> SuiResult<Option<ObjectID>>

pub fn get_total_transaction_blocks(&self) -> SuiResult<u64>

pub async fn get_executed_transaction_and_effects( &self, digest: TransactionDigest, kv_store: Arc<TransactionKeyValueStore> ) -> SuiResult<(Transaction, TransactionEffects)>

pub fn multi_get_checkpoint_by_sequence_number( &self, sequence_numbers: &[CheckpointSequenceNumber] ) -> SuiResult<Vec<Option<VerifiedCheckpoint>>>

pub fn get_transaction_events( &self, digest: &TransactionEventsDigest ) -> SuiResult<TransactionEvents>

pub fn get_transaction_input_objects( &self, effects: &TransactionEffects ) -> Result<Vec<Object>>

pub fn get_transaction_output_objects( &self, effects: &TransactionEffects ) -> Result<Vec<Object>>

pub fn loaded_child_object_versions( &self, transaction_digest: &TransactionDigest ) -> SuiResult<Option<Vec<(ObjectID, SequenceNumber)>>>

pub async fn get_transactions_for_tests( self: &Arc<Self>, filter: Option<TransactionFilter>, cursor: Option<TransactionDigest>, limit: Option<usize>, reverse: bool ) -> SuiResult<Vec<TransactionDigest>>

pub async fn get_transactions( &self, kv_store: &Arc<TransactionKeyValueStore>, filter: Option<TransactionFilter>, cursor: Option<TransactionDigest>, limit: Option<usize>, reverse: bool ) -> SuiResult<Vec<TransactionDigest>>

pub fn get_checkpoint_store(&self) -> &Arc<CheckpointStore>

pub fn get_latest_checkpoint_sequence_number( &self ) -> SuiResult<CheckpointSequenceNumber>

pub fn get_checkpoint_summary_by_sequence_number( &self, sequence_number: CheckpointSequenceNumber ) -> SuiResult<CheckpointSummary>

pub fn get_checkpoint_summary_by_digest( &self, digest: CheckpointDigest ) -> SuiResult<CheckpointSummary>

pub fn find_publish_txn_digest( &self, package_id: ObjectID ) -> SuiResult<TransactionDigest>

pub fn find_genesis_txn_digest(&self) -> SuiResult<TransactionDigest>

pub fn get_verified_checkpoint_by_sequence_number( &self, sequence_number: CheckpointSequenceNumber ) -> SuiResult<VerifiedCheckpoint>

pub fn get_verified_checkpoint_summary_by_digest( &self, digest: CheckpointDigest ) -> SuiResult<VerifiedCheckpoint>

pub fn get_checkpoint_contents( &self, digest: CheckpointContentsDigest ) -> SuiResult<CheckpointContents>

pub fn get_checkpoint_contents_by_sequence_number( &self, sequence_number: CheckpointSequenceNumber ) -> SuiResult<CheckpointContents>

pub async fn query_events( &self, kv_store: &Arc<TransactionKeyValueStore>, query: EventFilter, cursor: Option<EventID>, limit: usize, descending: bool ) -> SuiResult<Vec<SuiEvent>>

pub async fn insert_genesis_object(&self, object: Object)

pub async fn insert_genesis_objects(&self, objects: &[Object])

pub fn get_transaction_status( &self, transaction_digest: &TransactionDigest, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult<Option<(SenderSignedData, TransactionStatus)>>

Make a status response for a transaction

pub fn get_signed_effects_and_maybe_resign( &self, transaction_digest: &TransactionDigest, epoch_store: &Arc<AuthorityPerEpochStore> ) -> SuiResult<Option<VerifiedSignedTransactionEffects>>

Get the signed effects of the given transaction. If the effects was signed in a previous epoch, re-sign it so that the caller is able to form a cert of the effects in the current epoch.

pub async fn get_transaction_lock( &self, object_ref: &ObjectRef, epoch_store: &AuthorityPerEpochStore ) -> SuiResult<Option<VerifiedSignedTransaction>>

Get the TransactionEnvelope that currently locks the given object, if any. Since object locks are only valid for one epoch, we also need the epoch_id in the query. Returns UserInputError::ObjectNotFound if no lock records for the given object can be found. Returns UserInputError::ObjectVersionUnavailableForConsumption if the object record is at a different version. Returns Some(VerifiedEnvelope) if the given ObjectRef is locked by a certain transaction. Returns None if the a lock record is initialized for the given ObjectRef but not yet locked by any transaction, or cannot find the transaction in transaction table, because of data race etc.

pub async fn get_objects( &self, objects: &[ObjectID] ) -> SuiResult<Vec<Option<Object>>>

pub async fn get_object_or_tombstone( &self, object_id: ObjectID ) -> SuiResult<Option<ObjectRef>>

pub fn set_override_protocol_upgrade_buffer_stake( &self, expected_epoch: EpochId, buffer_stake_bps: u64 ) -> SuiResult

Ordinarily, protocol upgrades occur when 2f + 1 + (f * ProtocolConfig::buffer_stake_for_protocol_upgrade_bps) vote for the upgrade.

This method can be used to dynamic adjust the amount of buffer. If set to 0, the upgrade will go through with only 2f+1 votes.

IMPORTANT: If this is used, it must be used on >=2f+1 validators (all should have the same value), or you risk halting the chain.

pub fn clear_override_protocol_upgrade_buffer_stake( &self, expected_epoch: EpochId ) -> SuiResult

pub async fn get_available_system_packages( &self, binary_config: &BinaryConfig ) -> Vec<ObjectRef>

Get the set of system packages that are compiled in to this build, if those packages are compatible with the current versions of those packages on-chain.

pub async fn create_and_execute_advance_epoch_tx( &self, epoch_store: &Arc<AuthorityPerEpochStore>, gas_cost_summary: &GasCostSummary, checkpoint: CheckpointSequenceNumber, epoch_start_timestamp_ms: CheckpointTimestamp ) -> Result<(SuiSystemState, TransactionEffects)>

Creates and execute the advance epoch transaction to effects without committing it to the database. The effects of the change epoch tx are only written to the database after a certified checkpoint has been formed and executed by CheckpointExecutor.

When a framework upgraded has been decided on, but the validator does not have the new versions of the packages locally, the validator cannot form the ChangeEpochTx. In this case it returns Err, indicating that the checkpoint builder should give up trying to make the final checkpoint. As long as the network is able to create a certified checkpoint (which should be ensured by the capabilities vote), it will arrive via state sync and be executed by CheckpointExecutor.

pub async fn prune_objects_and_compact_for_testing(&self)

pub async fn insert_objects_unsafe_for_testing_only( &self, objects: &[Object] ) -> SuiResult

NOTE: this function is only to be used for fuzzing and testing. Never use in prod

Trait Implementations

impl TransactionKeyValueStoreTrait for AuthorityState

fn multi_get<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, transactions: &'life1 [TransactionDigest], effects: &'life2 [TransactionDigest], events: &'life3 [TransactionEventsDigest] ) -> Pin<Box<dyn Future<Output = SuiResult<(Vec<Option<Transaction>>, Vec<Option<TransactionEffects>>, Vec<Option<TransactionEvents>>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Generic multi_get, allows implementors to get heterogenous values with a single round trip.

fn multi_get_checkpoints<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, checkpoint_summaries: &'life1 [CheckpointSequenceNumber], checkpoint_contents: &'life2 [CheckpointSequenceNumber], checkpoint_summaries_by_digest: &'life3 [CheckpointDigest], checkpoint_contents_by_digest: &'life4 [CheckpointContentsDigest] ) -> Pin<Box<dyn Future<Output = SuiResult<(Vec<Option<CertifiedCheckpointSummary>>, Vec<Option<CheckpointContents>>, Vec<Option<CertifiedCheckpointSummary>>, Vec<Option<CheckpointContents>>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Generic multi_get to allow implementors to get heterogenous values with a single round trip.

fn deprecated_get_transaction_checkpoint<'life0, 'async_trait>( &'life0 self, digest: TransactionDigest ) -> Pin<Box<dyn Future<Output = SuiResult<Option<CheckpointSequenceNumber>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_object<'life0, 'async_trait>( &'life0 self, object_id: ObjectID, version: VersionNumber ) -> Pin<Box<dyn Future<Output = SuiResult<Option<Object>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn multi_get_transaction_checkpoint<'life0, 'life1, 'async_trait>( &'life0 self, digests: &'life1 [TransactionDigest] ) -> Pin<Box<dyn Future<Output = SuiResult<Vec<Option<CheckpointSequenceNumber>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,