@aptos-labs/ts-sdk 2.0.1-zeta.0 → 3.0.0

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

@@ -1,228 +0,0 @@
-/// 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

@@ -1,121 +0,0 @@
-/// 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

@@ -1,92 +0,0 @@
-/// 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

@@ -1,66 +0,0 @@
-/// 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

@@ -1,100 +0,0 @@
-/// 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;
-}