@aptos-labs/ts-sdk 1.36.0 → 1.37.0

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

@@ -0,0 +1,228 @@
+/// This defines the fungible asset module that can issue fungible asset of any `Metadata` object. The
+/// metadata object can be any object that equipped with `Metadata` resource.
+///
+/// The dispatchable_fungible_asset wraps the existing fungible_asset module and adds the ability for token issuer
+/// to customize the logic for withdraw and deposit operations. For example:
+///
+/// - Deflation token: a fixed percentage of token will be destructed upon transfer.
+/// - Transfer allowlist: token can only be transfered to addresses in the allow list.
+/// - Predicated transfer: transfer can only happen when some certain predicate has been met.
+/// - Loyalty token: a fixed loyalty will be paid to a designated address when a fungible asset transfer happens
+///
+/// The api listed here intended to be an in-place replacement for defi applications that uses fungible_asset api directly
+/// and is safe for non-dispatchable (aka vanilla) fungible assets as well.
+///
+/// See AIP-73 for further discussion
+///
+module aptos_framework::dispatchable_fungible_asset {
+    use aptos_framework::fungible_asset::{Self, FungibleAsset, TransferRef};
+    use aptos_framework::function_info::{Self, FunctionInfo};
+    use aptos_framework::object::{Self, ConstructorRef, Object};
+
+    use std::error;
+    use std::features;
+    use std::option::{Self, Option};
+
+    /// TransferRefStore doesn't exist on the fungible asset type.
+    const ESTORE_NOT_FOUND: u64 = 1;
+    /// Recipient is not getting the guaranteed value;
+    const EAMOUNT_MISMATCH: u64 = 2;
+    /// Feature is not activated yet on the network.
+    const ENOT_ACTIVATED: u64 = 3;
+    /// Dispatch target is not loaded.
+    const ENOT_LOADED: u64 = 4;
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct TransferRefStore has key {
+        transfer_ref: TransferRef
+    }
+
+    public fun register_dispatch_functions(
+        constructor_ref: &ConstructorRef,
+        withdraw_function: Option<FunctionInfo>,
+        deposit_function: Option<FunctionInfo>,
+        derived_balance_function: Option<FunctionInfo>,
+    ) {
+        fungible_asset::register_dispatch_functions(
+            constructor_ref,
+            withdraw_function,
+            deposit_function,
+            derived_balance_function,
+        );
+        let store_obj = &object::generate_signer(constructor_ref);
+        move_to<TransferRefStore>(
+            store_obj,
+            TransferRefStore {
+                transfer_ref: fungible_asset::generate_transfer_ref(constructor_ref),
+            }
+        );
+    }
+
+    public fun register_derive_supply_dispatch_function(
+        constructor_ref: &ConstructorRef,
+        dispatch_function: Option<FunctionInfo>
+    ) {
+        fungible_asset::register_derive_supply_dispatch_function(
+            constructor_ref,
+            dispatch_function
+        );
+    }
+
+    /// Withdraw `amount` of the fungible asset from `store` by the owner.
+    ///
+    /// The semantics of deposit will be governed by the function specified in DispatchFunctionStore.
+    public fun withdraw<T: key>(
+        owner: &signer,
+        store: Object<T>,
+        amount: u64,
+    ): FungibleAsset acquires TransferRefStore {
+        fungible_asset::withdraw_sanity_check(owner, store, false);
+        let func_opt = fungible_asset::withdraw_dispatch_function(store);
+        if (option::is_some(&func_opt)) {
+            assert!(
+                features::dispatchable_fungible_asset_enabled(),
+                error::aborted(ENOT_ACTIVATED)
+            );
+            let start_balance = fungible_asset::balance(store);
+            let func = option::borrow(&func_opt);
+            function_info::load_module_from_function(func);
+            let fa = dispatchable_withdraw(
+                store,
+                amount,
+                borrow_transfer_ref(store),
+                func,
+            );
+            let end_balance = fungible_asset::balance(store);
+            assert!(amount <= start_balance - end_balance, error::aborted(EAMOUNT_MISMATCH));
+            fa
+        } else {
+            fungible_asset::withdraw_internal(object::object_address(&store), amount)
+        }
+    }
+
+    /// Deposit `amount` of the fungible asset to `store`.
+    ///
+    /// The semantics of deposit will be governed by the function specified in DispatchFunctionStore.
+    public fun deposit<T: key>(store: Object<T>, fa: FungibleAsset) acquires TransferRefStore {
+        fungible_asset::deposit_sanity_check(store, false);
+        let func_opt = fungible_asset::deposit_dispatch_function(store);
+        if (option::is_some(&func_opt)) {
+            assert!(
+                features::dispatchable_fungible_asset_enabled(),
+                error::aborted(ENOT_ACTIVATED)
+            );
+            let func = option::borrow(&func_opt);
+            function_info::load_module_from_function(func);
+            dispatchable_deposit(
+                store,
+                fa,
+                borrow_transfer_ref(store),
+                func
+            )
+        } else {
+            fungible_asset::deposit_internal(object::object_address(&store), fa)
+        }
+    }
+
+    /// Transfer an `amount` of fungible asset from `from_store`, which should be owned by `sender`, to `receiver`.
+    /// Note: it does not move the underlying object.
+    public entry fun transfer<T: key>(
+        sender: &signer,
+        from: Object<T>,
+        to: Object<T>,
+        amount: u64,
+    ) acquires TransferRefStore {
+        let fa = withdraw(sender, from, amount);
+        deposit(to, fa);
+    }
+
+    /// Transfer an `amount` of fungible asset from `from_store`, which should be owned by `sender`, to `receiver`.
+    /// The recipient is guranteed to receive asset greater than the expected amount.
+    /// Note: it does not move the underlying object.
+    public entry fun transfer_assert_minimum_deposit<T: key>(
+        sender: &signer,
+        from: Object<T>,
+        to: Object<T>,
+        amount: u64,
+        expected: u64
+    ) acquires TransferRefStore {
+        let start = fungible_asset::balance(to);
+        let fa = withdraw(sender, from, amount);
+        deposit(to, fa);
+        let end = fungible_asset::balance(to);
+        assert!(end - start >= expected, error::aborted(EAMOUNT_MISMATCH));
+    }
+
+    #[view]
+    /// Get the derived value of store using the overloaded hook.
+    ///
+    /// The semantics of value will be governed by the function specified in DispatchFunctionStore.
+    public fun derived_balance<T: key>(store: Object<T>): u64 {
+        let func_opt = fungible_asset::derived_balance_dispatch_function(store);
+        if (option::is_some(&func_opt)) {
+            assert!(
+                features::dispatchable_fungible_asset_enabled(),
+                error::aborted(ENOT_ACTIVATED)
+            );
+            let func = option::borrow(&func_opt);
+            function_info::load_module_from_function(func);
+            dispatchable_derived_balance(store, func)
+        } else {
+            fungible_asset::balance(store)
+        }
+    }
+
+    #[view]
+    /// Get the derived supply of the fungible asset using the overloaded hook.
+    ///
+    /// The semantics of supply will be governed by the function specified in DeriveSupplyDispatch.
+    public fun derived_supply<T: key>(metadata: Object<T>): Option<u128> {
+        let func_opt = fungible_asset::derived_supply_dispatch_function(metadata);
+        if (option::is_some(&func_opt)) {
+            assert!(
+                features::dispatchable_fungible_asset_enabled(),
+                error::aborted(ENOT_ACTIVATED)
+            );
+            let func = option::borrow(&func_opt);
+            function_info::load_module_from_function(func);
+            dispatchable_derived_supply(metadata, func)
+        } else {
+            fungible_asset::supply(metadata)
+        }
+    }
+
+    inline fun borrow_transfer_ref<T: key>(metadata: Object<T>): &TransferRef acquires TransferRefStore {
+        let metadata_addr = object::object_address(
+            &fungible_asset::store_metadata(metadata)
+        );
+        assert!(
+            exists<TransferRefStore>(metadata_addr),
+            error::not_found(ESTORE_NOT_FOUND)
+        );
+        &borrow_global<TransferRefStore>(metadata_addr).transfer_ref
+    }
+
+    native fun dispatchable_withdraw<T: key>(
+        store: Object<T>,
+        amount: u64,
+        transfer_ref: &TransferRef,
+        function: &FunctionInfo,
+    ): FungibleAsset;
+
+    native fun dispatchable_deposit<T: key>(
+        store: Object<T>,
+        fa: FungibleAsset,
+        transfer_ref: &TransferRef,
+        function: &FunctionInfo,
+    );
+
+    native fun dispatchable_derived_balance<T: key>(
+        store: Object<T>,
+        function: &FunctionInfo,
+    ): u64;
+
+    native fun dispatchable_derived_supply<T: key>(
+        store: Object<T>,
+        function: &FunctionInfo,
+    ): Option<u128>;
+}

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

@@ -0,0 +1,121 @@
+/// DKG on-chain states and helper functions.
+module aptos_framework::dkg {
+    use std::error;
+    use std::option;
+    use std::option::Option;
+    use aptos_framework::event::emit;
+    use aptos_framework::randomness_config::RandomnessConfig;
+    use aptos_framework::system_addresses;
+    use aptos_framework::timestamp;
+    use aptos_framework::validator_consensus_info::ValidatorConsensusInfo;
+    friend aptos_framework::block;
+    friend aptos_framework::reconfiguration_with_dkg;
+
+    const EDKG_IN_PROGRESS: u64 = 1;
+    const EDKG_NOT_IN_PROGRESS: u64 = 2;
+
+    /// This can be considered as the public input of DKG.
+    struct DKGSessionMetadata has copy, drop, store {
+        dealer_epoch: u64,
+        randomness_config: RandomnessConfig,
+        dealer_validator_set: vector<ValidatorConsensusInfo>,
+        target_validator_set: vector<ValidatorConsensusInfo>,
+    }
+
+    #[event]
+    struct DKGStartEvent has drop, store {
+        session_metadata: DKGSessionMetadata,
+        start_time_us: u64,
+    }
+
+    /// The input and output of a DKG session.
+    /// The validator set of epoch `x` works together for an DKG output for the target validator set of epoch `x+1`.
+    struct DKGSessionState has copy, store, drop {
+        metadata: DKGSessionMetadata,
+        start_time_us: u64,
+        transcript: vector<u8>,
+    }
+
+    /// The completed and in-progress DKG sessions.
+    struct DKGState has key {
+        last_completed: Option<DKGSessionState>,
+        in_progress: Option<DKGSessionState>,
+    }
+
+    /// Called in genesis to initialize on-chain states.
+    public fun initialize(aptos_framework: &signer) {
+        system_addresses::assert_aptos_framework(aptos_framework);
+        if (!exists<DKGState>(@aptos_framework)) {
+            move_to<DKGState>(
+                aptos_framework,
+                DKGState {
+                    last_completed: std::option::none(),
+                    in_progress: std::option::none(),
+                }
+            );
+        }
+    }
+
+    /// Mark on-chain DKG state as in-progress. Notify validators to start DKG.
+    /// Abort if a DKG is already in progress.
+    public(friend) fun start(
+        dealer_epoch: u64,
+        randomness_config: RandomnessConfig,
+        dealer_validator_set: vector<ValidatorConsensusInfo>,
+        target_validator_set: vector<ValidatorConsensusInfo>,
+    ) acquires DKGState {
+        let dkg_state = borrow_global_mut<DKGState>(@aptos_framework);
+        let new_session_metadata = DKGSessionMetadata {
+            dealer_epoch,
+            randomness_config,
+            dealer_validator_set,
+            target_validator_set,
+        };
+        let start_time_us = timestamp::now_microseconds();
+        dkg_state.in_progress = std::option::some(DKGSessionState {
+            metadata: new_session_metadata,
+            start_time_us,
+            transcript: vector[],
+        });
+
+        emit(DKGStartEvent {
+            start_time_us,
+            session_metadata: new_session_metadata,
+        });
+    }
+
+    /// Put a transcript into the currently incomplete DKG session, then mark it completed.
+    ///
+    /// Abort if DKG is not in progress.
+    public(friend) fun finish(transcript: vector<u8>) acquires DKGState {
+        let dkg_state = borrow_global_mut<DKGState>(@aptos_framework);
+        assert!(option::is_some(&dkg_state.in_progress), error::invalid_state(EDKG_NOT_IN_PROGRESS));
+        let session = option::extract(&mut dkg_state.in_progress);
+        session.transcript = transcript;
+        dkg_state.last_completed = option::some(session);
+        dkg_state.in_progress = option::none();
+    }
+
+    /// Delete the currently incomplete session, if it exists.
+    public fun try_clear_incomplete_session(fx: &signer) acquires DKGState {
+        system_addresses::assert_aptos_framework(fx);
+        if (exists<DKGState>(@aptos_framework)) {
+            let dkg_state = borrow_global_mut<DKGState>(@aptos_framework);
+            dkg_state.in_progress = option::none();
+        }
+    }
+
+    /// Return the incomplete DKG session state, if it exists.
+    public fun incomplete_session(): Option<DKGSessionState> acquires DKGState {
+        if (exists<DKGState>(@aptos_framework)) {
+            borrow_global<DKGState>(@aptos_framework).in_progress
+        } else {
+            option::none()
+        }
+    }
+
+    /// Return the dealer epoch of a `DKGSessionState`.
+    public fun session_dealer_epoch(session: &DKGSessionState): u64 {
+        session.metadata.dealer_epoch
+    }
+}

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

@@ -0,0 +1,92 @@
+/// The Event module defines an `EventHandleGenerator` that is used to create
+/// `EventHandle`s with unique GUIDs. It contains a counter for the number
+/// of `EventHandle`s it generates. An `EventHandle` is used to count the number of
+/// events emitted to a handle and emit events to the event store.
+module aptos_framework::event {
+    use std::bcs;
+
+    use aptos_framework::guid::GUID;
+
+    friend aptos_framework::account;
+    friend aptos_framework::object;
+
+    /// Emit a module event with payload `msg`.
+    public fun emit<T: store + drop>(msg: T) {
+        write_module_event_to_store<T>(msg);
+    }
+
+    /// Log `msg` with the event stream identified by `T`
+    native fun write_module_event_to_store<T: drop + store>(msg: T);
+
+    #[test_only]
+    public native fun emitted_events<T: drop + store>(): vector<T>;
+
+    #[test_only]
+    public fun was_event_emitted<T: drop + store>(msg: &T): bool {
+        use std::vector;
+        vector::contains(&emitted_events<T>(), msg)
+    }
+
+    #[deprecated]
+    /// A handle for an event such that:
+    /// 1. Other modules can emit events to this handle.
+    /// 2. Storage can use this handle to prove the total number of events that happened in the past.
+    struct EventHandle<phantom T: drop + store> has store {
+        /// Total number of events emitted to this event stream.
+        counter: u64,
+        /// A globally unique ID for this event stream.
+        guid: GUID,
+    }
+
+    #[deprecated]
+    /// Use EventHandleGenerator to generate a unique event handle for `sig`
+    public(friend) fun new_event_handle<T: drop + store>(guid: GUID): EventHandle<T> {
+        EventHandle<T> {
+            counter: 0,
+            guid,
+        }
+    }
+
+    #[deprecated]
+    /// Emit an event with payload `msg` by using `handle_ref`'s key and counter.
+    public fun emit_event<T: drop + store>(handle_ref: &mut EventHandle<T>, msg: T) {
+        write_to_event_store<T>(bcs::to_bytes(&handle_ref.guid), handle_ref.counter, msg);
+        spec {
+            assume handle_ref.counter + 1 <= MAX_U64;
+        };
+        handle_ref.counter = handle_ref.counter + 1;
+    }
+
+    #[deprecated]
+    /// Return the GUID associated with this EventHandle
+    public fun guid<T: drop + store>(handle_ref: &EventHandle<T>): &GUID {
+        &handle_ref.guid
+    }
+
+    #[deprecated]
+    /// Return the current counter associated with this EventHandle
+    public fun counter<T: drop + store>(handle_ref: &EventHandle<T>): u64 {
+        handle_ref.counter
+    }
+
+    #[deprecated]
+    /// Log `msg` as the `count`th event associated with the event stream identified by `guid`
+    native fun write_to_event_store<T: drop + store>(guid: vector<u8>, count: u64, msg: T);
+
+    #[deprecated]
+    /// Destroy a unique handle.
+    public fun destroy_handle<T: drop + store>(handle: EventHandle<T>) {
+        EventHandle<T> { counter: _, guid: _ } = handle;
+    }
+
+    #[deprecated]
+    #[test_only]
+    public native fun emitted_events_by_handle<T: drop + store>(handle: &EventHandle<T>): vector<T>;
+
+    #[deprecated]
+    #[test_only]
+    public fun was_event_emitted_by_handle<T: drop + store>(handle: &EventHandle<T>, msg: &T): bool {
+        use std::vector;
+        vector::contains(&emitted_events_by_handle(handle), msg)
+    }
+}

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

@@ -0,0 +1,66 @@
+/// Maintains the execution config for the blockchain. The config is stored in a
+/// Reconfiguration, and may be updated by root.
+module aptos_framework::execution_config {
+    use aptos_framework::config_buffer;
+    use std::error;
+    use std::vector;
+    use aptos_framework::chain_status;
+
+    use aptos_framework::reconfiguration;
+    use aptos_framework::system_addresses;
+    friend aptos_framework::genesis;
+    friend aptos_framework::reconfiguration_with_dkg;
+
+    struct ExecutionConfig has drop, key, store {
+        config: vector<u8>,
+    }
+
+    /// The provided on chain config bytes are empty or invalid
+    const EINVALID_CONFIG: u64 = 1;
+
+    /// 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 ExecutionConfig {
+        system_addresses::assert_aptos_framework(account);
+        chain_status::assert_genesis();
+
+        assert!(vector::length(&config) > 0, error::invalid_argument(EINVALID_CONFIG));
+
+        if (exists<ExecutionConfig>(@aptos_framework)) {
+            let config_ref = &mut borrow_global_mut<ExecutionConfig>(@aptos_framework).config;
+            *config_ref = config;
+        } else {
+            move_to(account, ExecutionConfig { 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 execution configs for the next epoch.
+    /// Example usage:
+    /// ```
+    /// aptos_framework::execution_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));
+        config_buffer::upsert(ExecutionConfig { config });
+    }
+
+    /// Only used in reconfigurations to apply the pending `ExecutionConfig`, if there is any.
+    public(friend) fun on_new_epoch(framework: &signer) acquires ExecutionConfig {
+        system_addresses::assert_aptos_framework(framework);
+        if (config_buffer::does_exist<ExecutionConfig>()) {
+            let config = config_buffer::extract<ExecutionConfig>();
+            if (exists<ExecutionConfig>(@aptos_framework)) {
+                *borrow_global_mut<ExecutionConfig>(@aptos_framework) = config;
+            } else {
+                move_to(framework, config);
+            };
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+/// The `function_info` module defines the `FunctionInfo` type which simulates a function pointer.
+module aptos_framework::function_info {
+    use std::error;
+    use std::features;
+    use std::signer;
+    use std::string::{Self, String};
+
+    friend aptos_framework::fungible_asset;
+    friend aptos_framework::dispatchable_fungible_asset;
+
+    /// String is not a valid Move identifier
+    const EINVALID_IDENTIFIER: u64 = 1;
+    /// Function specified in the FunctionInfo doesn't exist on chain.
+    const EINVALID_FUNCTION: u64 = 2;
+    /// Feature hasn't been activated yet.
+    const ENOT_ACTIVATED: u64 = 3;
+
+    /// A `String` holds a sequence of bytes which is guaranteed to be in utf8 format.
+    struct FunctionInfo has copy, drop, store {
+        module_address: address,
+        module_name: String,
+        function_name: String,
+    }
+
+    /// Creates a new function info from names.
+    public fun new_function_info(
+        module_signer: &signer,
+        module_name: String,
+        function_name: String,
+    ): FunctionInfo {
+        new_function_info_from_address(
+            signer::address_of(module_signer),
+            module_name,
+            function_name,
+        )
+    }
+
+    public(friend) fun new_function_info_from_address(
+        module_address: address,
+        module_name: String,
+        function_name: String,
+    ): FunctionInfo {
+        assert!(
+            is_identifier(string::bytes(&module_name)),
+            EINVALID_IDENTIFIER
+        );
+        assert!(
+            is_identifier(string::bytes(&function_name)),
+            EINVALID_IDENTIFIER
+        );
+        FunctionInfo {
+            module_address,
+            module_name,
+            function_name,
+        }
+    }
+
+    /// Check if the dispatch target function meets the type requirements of the disptach entry point.
+    ///
+    /// framework_function is the dispatch native function defined in the aptos_framework.
+    /// dispatch_target is the function passed in by the user.
+    ///
+    /// dispatch_target should have the same signature (same argument type, same generics constraint) except
+    /// that the framework_function will have a `&FunctionInfo` in the last argument that will instruct the VM which
+    /// function to jump to.
+    ///
+    /// dispatch_target also needs to be public so the type signature will remain unchanged.
+    public(friend) fun check_dispatch_type_compatibility(
+        framework_function: &FunctionInfo,
+        dispatch_target: &FunctionInfo,
+    ): bool {
+        assert!(
+            features::dispatchable_fungible_asset_enabled(),
+            error::aborted(ENOT_ACTIVATED)
+        );
+        load_function_impl(dispatch_target);
+        check_dispatch_type_compatibility_impl(framework_function, dispatch_target)
+    }
+
+    /// Load up a function into VM's loader and charge for its dependencies
+    ///
+    /// It is **critical** to make sure that this function is invoked before `check_dispatch_type_compatibility`
+    /// or performing any other dispatching logic to ensure:
+    /// 1. We properly charge gas for the function to dispatch.
+    /// 2. The function is loaded in the cache so that we can perform further type checking/dispatching logic.
+    ///
+    /// Calling `check_dispatch_type_compatibility_impl` or dispatch without loading up the module would yield an error
+    /// if such module isn't accessed previously in the transaction.
+    public(friend) fun load_module_from_function(f: &FunctionInfo) {
+        load_function_impl(f)
+    }
+
+    native fun check_dispatch_type_compatibility_impl(lhs: &FunctionInfo, r: &FunctionInfo): bool;
+    native fun is_identifier(s: &vector<u8>): bool;
+    native fun load_function_impl(f: &FunctionInfo);
+
+    // Test only dependencies so we can invoke those friend functions.
+    #[test_only]
+    friend aptos_framework::function_info_tests;
+}