@aptos-labs/ts-sdk 1.29.0-zeta.0 → 1.29.0-zeta.2

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/config_buffer.move

@@ -0,0 +1,101 @@
+/// This wrapper helps store an on-chain config for the next epoch.
+///
+/// Once reconfigure with DKG is introduced, every on-chain config `C` should do the following.
+/// - Support async update when DKG is enabled. This is typically done by 3 steps below.
+///   - Implement `C::set_for_next_epoch()` using `upsert()` function in this module.
+///   - Implement `C::on_new_epoch()` using `extract()` function in this module.
+///   - Update `0x1::reconfiguration_with_dkg::finish()` to call `C::on_new_epoch()`.
+/// - Support sychronous update when DKG is disabled.
+///   This is typically done by implementing `C::set()` to update the config resource directly.
+///
+/// NOTE: on-chain config `0x1::state::ValidatorSet` implemented its own buffer.
+module aptos_framework::config_buffer {
+    use std::string::String;
+    use aptos_std::any;
+    use aptos_std::any::Any;
+    use aptos_std::simple_map;
+    use aptos_std::simple_map::SimpleMap;
+    use aptos_std::type_info;
+    use aptos_framework::system_addresses;
+
+    friend aptos_framework::consensus_config;
+    friend aptos_framework::execution_config;
+    friend aptos_framework::gas_schedule;
+    friend aptos_framework::jwks;
+    friend aptos_framework::jwk_consensus_config;
+    friend aptos_framework::keyless_account;
+    friend aptos_framework::randomness_api_v0_config;
+    friend aptos_framework::randomness_config;
+    friend aptos_framework::randomness_config_seqnum;
+    friend aptos_framework::version;
+
+    /// Config buffer operations failed with permission denied.
+    const ESTD_SIGNER_NEEDED: u64 = 1;
+
+    struct PendingConfigs has key {
+        configs: SimpleMap<String, Any>,
+    }
+
+    public fun initialize(aptos_framework: &signer) {
+        system_addresses::assert_aptos_framework(aptos_framework);
+        if (!exists<PendingConfigs>(@aptos_framework)) {
+            move_to(aptos_framework, PendingConfigs {
+                configs: simple_map::new(),
+            })
+        }
+    }
+
+    /// Check whether there is a pending config payload for `T`.
+    public fun does_exist<T: store>(): bool acquires PendingConfigs {
+        if (exists<PendingConfigs>(@aptos_framework)) {
+            let config = borrow_global<PendingConfigs>(@aptos_framework);
+            simple_map::contains_key(&config.configs, &type_info::type_name<T>())
+        } else {
+            false
+        }
+    }
+
+    /// Upsert an on-chain config to the buffer for the next epoch.
+    ///
+    /// Typically used in `X::set_for_next_epoch()` where X is an on-chain config.
+    public(friend) fun upsert<T: drop + store>(config: T) acquires PendingConfigs {
+        let configs = borrow_global_mut<PendingConfigs>(@aptos_framework);
+        let key = type_info::type_name<T>();
+        let value = any::pack(config);
+        simple_map::upsert(&mut configs.configs, key, value);
+    }
+
+    /// Take the buffered config `T` out (buffer cleared). Abort if the buffer is empty.
+    /// Should only be used at the end of a reconfiguration.
+    ///
+    /// Typically used in `X::on_new_epoch()` where X is an on-chaon config.
+    public fun extract<T: store>(): T acquires PendingConfigs {
+        let configs = borrow_global_mut<PendingConfigs>(@aptos_framework);
+        let key = type_info::type_name<T>();
+        let (_, value_packed) = simple_map::remove(&mut configs.configs, &key);
+        any::unpack(value_packed)
+    }
+
+    #[test_only]
+    struct DummyConfig has drop, store {
+        data: u64,
+    }
+
+    #[test(fx = @std)]
+    fun test_config_buffer_basic(fx: &signer) acquires PendingConfigs {
+        initialize(fx);
+        // Initially nothing in the buffer.
+        assert!(!does_exist<DummyConfig>(), 1);
+
+        // Insert should work.
+        upsert(DummyConfig { data: 888 });
+        assert!(does_exist<DummyConfig>(), 1);
+
+        // Update and extract should work.
+        upsert(DummyConfig { data: 999 });
+        assert!(does_exist<DummyConfig>(), 1);
+        let config = extract<DummyConfig>();
+        assert!(config == DummyConfig { data: 999 }, 1);
+        assert!(!does_exist<DummyConfig>(), 1);
+    }
+}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/consensus_config.move

@@ -0,0 +1,77 @@
+/// Maintains the consensus config for the blockchain. The config is stored in a
+/// Reconfiguration, and may be updated by root.
+module aptos_framework::consensus_config {
+    use std::error;
+    use std::vector;
+    use aptos_framework::chain_status;
+    use aptos_framework::config_buffer;
+
+    use aptos_framework::reconfiguration;
+    use aptos_framework::system_addresses;
+
+    friend aptos_framework::genesis;
+    friend aptos_framework::reconfiguration_with_dkg;
+
+    struct ConsensusConfig has drop, key, store {
+        config: vector<u8>,
+    }
+
+    /// The provided on chain config bytes are empty or invalid
+    const EINVALID_CONFIG: u64 = 1;
+
+    /// Publishes the ConsensusConfig config.
+    public(friend) fun initialize(aptos_framework: &signer, config: vector<u8>) {
+        system_addresses::assert_aptos_framework(aptos_framework);
+        assert!(vector::length(&config) > 0, error::invalid_argument(EINVALID_CONFIG));
+        move_to(aptos_framework, ConsensusConfig { config });
+    }
+
+    /// Deprecated by `set_for_next_epoch()`.
+    ///
+    /// WARNING: calling this while randomness is enabled will trigger a new epoch without randomness!
+    ///
+    /// TODO: update all the tests that reference this function, then disable this function.
+    public fun set(account: &signer, config: vector<u8>) acquires ConsensusConfig {
+        system_addresses::assert_aptos_framework(account);
+        chain_status::assert_genesis();
+        assert!(vector::length(&config) > 0, error::invalid_argument(EINVALID_CONFIG));
+
+        let config_ref = &mut borrow_global_mut<ConsensusConfig>(@aptos_framework).config;
+        *config_ref = config;
+
+        // Need to trigger reconfiguration so validator nodes can sync on the updated configs.
+        reconfiguration::reconfigure();
+    }
+
+    /// This can be called by on-chain governance to update on-chain consensus configs for the next epoch.
+    /// Example usage:
+    /// ```
+    /// aptos_framework::consensus_config::set_for_next_epoch(&framework_signer, some_config_bytes);
+    /// aptos_framework::aptos_governance::reconfigure(&framework_signer);
+    /// ```
+    public fun set_for_next_epoch(account: &signer, config: vector<u8>) {
+        system_addresses::assert_aptos_framework(account);
+        assert!(vector::length(&config) > 0, error::invalid_argument(EINVALID_CONFIG));
+        std::config_buffer::upsert<ConsensusConfig>(ConsensusConfig {config});
+    }
+
+    /// Only used in reconfigurations to apply the pending `ConsensusConfig`, if there is any.
+    public(friend) fun on_new_epoch(framework: &signer) acquires ConsensusConfig {
+        system_addresses::assert_aptos_framework(framework);
+        if (config_buffer::does_exist<ConsensusConfig>()) {
+            let new_config = config_buffer::extract<ConsensusConfig>();
+            if (exists<ConsensusConfig>(@aptos_framework)) {
+                *borrow_global_mut<ConsensusConfig>(@aptos_framework) = new_config;
+            } else {
+                move_to(framework, new_config);
+            };
+        }
+    }
+
+    public fun validator_txn_enabled(): bool acquires ConsensusConfig {
+        let config_bytes = borrow_global<ConsensusConfig>(@aptos_framework).config;
+        validator_txn_enabled_internal(config_bytes)
+    }
+
+    native fun validator_txn_enabled_internal(config_bytes: vector<u8>): bool;
+}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/create_signer.move

@@ -0,0 +1,21 @@
+/// Provides a common place for exporting `create_signer` across the Aptos Framework.
+///
+/// To use create_signer, add the module below, such that:
+/// `friend aptos_framework::friend_wants_create_signer`
+/// where `friend_wants_create_signer` is the module that needs `create_signer`.
+///
+/// Note, that this is only available within the Aptos Framework.
+///
+/// This exists to make auditing straight forward and to limit the need to depend
+/// on account to have access to this.
+module aptos_framework::create_signer {
+    friend aptos_framework::account;
+    friend aptos_framework::aptos_account;
+    friend aptos_framework::coin;
+    friend aptos_framework::fungible_asset;
+    friend aptos_framework::genesis;
+    friend aptos_framework::multisig_account;
+    friend aptos_framework::object;
+
+    public(friend) native fun create_signer(addr: address): signer;
+}