@aptos-labs/ts-sdk 2.0.0 → 2.0.1

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

@@ -0,0 +1,1566 @@
+/// 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.
+module aptos_framework::fungible_asset {
+    use aptos_framework::aggregator_v2::{Self, Aggregator};
+    use aptos_framework::create_signer;
+    use aptos_framework::event;
+    use aptos_framework::function_info::{Self, FunctionInfo};
+    use aptos_framework::object::{Self, Object, ConstructorRef, DeleteRef, ExtendRef};
+    use std::string;
+    use std::features;
+
+    use std::error;
+    use std::option::{Self, Option};
+    use std::signer;
+    use std::string::String;
+
+    friend aptos_framework::coin;
+    friend aptos_framework::primary_fungible_store;
+    friend aptos_framework::aptos_account;
+
+    friend aptos_framework::dispatchable_fungible_asset;
+
+    /// Amount cannot be zero.
+    const EAMOUNT_CANNOT_BE_ZERO: u64 = 1;
+    /// The transfer ref and the fungible asset do not match.
+    const ETRANSFER_REF_AND_FUNGIBLE_ASSET_MISMATCH: u64 = 2;
+    /// Store is disabled from sending and receiving this fungible asset.
+    const ESTORE_IS_FROZEN: u64 = 3;
+    /// Insufficient balance to withdraw or transfer.
+    const EINSUFFICIENT_BALANCE: u64 = 4;
+    /// The fungible asset's supply has exceeded maximum.
+    const EMAX_SUPPLY_EXCEEDED: u64 = 5;
+    /// Fungible asset do not match when merging.
+    const EFUNGIBLE_ASSET_MISMATCH: u64 = 6;
+    /// The mint ref and the store do not match.
+    const EMINT_REF_AND_STORE_MISMATCH: u64 = 7;
+    /// Account is not the store's owner.
+    const ENOT_STORE_OWNER: u64 = 8;
+    /// Transfer ref and store do not match.
+    const ETRANSFER_REF_AND_STORE_MISMATCH: u64 = 9;
+    /// Burn ref and store do not match.
+    const EBURN_REF_AND_STORE_MISMATCH: u64 = 10;
+    /// Fungible asset and store do not match.
+    const EFUNGIBLE_ASSET_AND_STORE_MISMATCH: u64 = 11;
+    /// Cannot destroy non-empty fungible assets.
+    const EAMOUNT_IS_NOT_ZERO: u64 = 12;
+    /// Burn ref and fungible asset do not match.
+    const EBURN_REF_AND_FUNGIBLE_ASSET_MISMATCH: u64 = 13;
+    /// Cannot destroy fungible stores with a non-zero balance.
+    const EBALANCE_IS_NOT_ZERO: u64 = 14;
+    /// Name of the fungible asset metadata is too long
+    const ENAME_TOO_LONG: u64 = 15;
+    /// Symbol of the fungible asset metadata is too long
+    const ESYMBOL_TOO_LONG: u64 = 16;
+    /// Decimals is over the maximum of 32
+    const EDECIMALS_TOO_LARGE: u64 = 17;
+    /// Fungibility is only available for non-deletable objects.
+    const EOBJECT_IS_DELETABLE: u64 = 18;
+    /// URI for the icon of the fungible asset metadata is too long
+    const EURI_TOO_LONG: u64 = 19;
+    /// The fungible asset's supply will be negative which should be impossible.
+    const ESUPPLY_UNDERFLOW: u64 = 20;
+    /// Supply resource is not found for a metadata object.
+    const ESUPPLY_NOT_FOUND: u64 = 21;
+    /// Flag for Concurrent Supply not enabled
+    const ECONCURRENT_SUPPLY_NOT_ENABLED: u64 = 22;
+    /// Flag for the existence of fungible store.
+    const EFUNGIBLE_STORE_EXISTENCE: u64 = 23;
+    /// Account is not the owner of metadata object.
+    const ENOT_METADATA_OWNER: u64 = 24;
+    /// Provided withdraw function type doesn't meet the signature requirement.
+    const EWITHDRAW_FUNCTION_SIGNATURE_MISMATCH: u64 = 25;
+    /// Provided deposit function type doesn't meet the signature requirement.
+    const EDEPOSIT_FUNCTION_SIGNATURE_MISMATCH: u64 = 26;
+    /// Provided derived_balance function type doesn't meet the signature requirement.
+    const EDERIVED_BALANCE_FUNCTION_SIGNATURE_MISMATCH: u64 = 27;
+    /// Invalid withdraw/deposit on dispatchable token. The specified token has a dispatchable function hook.
+    /// Need to invoke dispatchable_fungible_asset::withdraw/deposit to perform transfer.
+    const EINVALID_DISPATCHABLE_OPERATIONS: u64 = 28;
+    /// Trying to re-register dispatch hook on a fungible asset.
+    const EALREADY_REGISTERED: u64 = 29;
+    /// Fungible metadata does not exist on this account.
+    const EFUNGIBLE_METADATA_EXISTENCE: u64 = 30;
+    /// Cannot register dispatch hook for APT.
+    const EAPT_NOT_DISPATCHABLE: u64 = 31;
+    /// Flag for Concurrent Supply not enabled
+    const ECONCURRENT_BALANCE_NOT_ENABLED: u64 = 32;
+    /// Provided derived_supply function type doesn't meet the signature requirement.
+    const EDERIVED_SUPPLY_FUNCTION_SIGNATURE_MISMATCH: u64 = 33;
+
+    //
+    // Constants
+    //
+
+    const MAX_NAME_LENGTH: u64 = 32;
+    const MAX_SYMBOL_LENGTH: u64 = 10;
+    const MAX_DECIMALS: u8 = 32;
+    const MAX_URI_LENGTH: u64 = 512;
+
+    /// Maximum possible coin supply.
+    const MAX_U128: u128 = 340282366920938463463374607431768211455;
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct Supply has key {
+        current: u128,
+        // option::none() means unlimited supply.
+        maximum: Option<u128>,
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct ConcurrentSupply has key {
+        current: Aggregator<u128>,
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    /// Metadata of a Fungible asset
+    struct Metadata has key, copy, drop {
+        /// Name of the fungible metadata, i.e., "USDT".
+        name: String,
+        /// Symbol of the fungible metadata, usually a shorter version of the name.
+        /// For example, Singapore Dollar is SGD.
+        symbol: String,
+        /// Number of decimals used for display purposes.
+        /// For example, if `decimals` equals `2`, a balance of `505` coins should
+        /// be displayed to a user as `5.05` (`505 / 10 ** 2`).
+        decimals: u8,
+        /// The Uniform Resource Identifier (uri) pointing to an image that can be used as the icon for this fungible
+        /// asset.
+        icon_uri: String,
+        /// The Uniform Resource Identifier (uri) pointing to the website for the fungible asset.
+        project_uri: String,
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    /// Defines a `FungibleAsset`, such that all `FungibleStore`s stores are untransferable at
+    /// the object layer.
+    struct Untransferable has key {}
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    /// The store object that holds fungible assets of a specific type associated with an account.
+    struct FungibleStore has key {
+        /// The address of the base metadata object.
+        metadata: Object<Metadata>,
+        /// The balance of the fungible metadata.
+        balance: u64,
+        /// If true, owner transfer is disabled that only `TransferRef` can move in/out from this store.
+        frozen: bool,
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct DispatchFunctionStore has key {
+		withdraw_function: Option<FunctionInfo>,
+		deposit_function: Option<FunctionInfo>,
+        derived_balance_function: Option<FunctionInfo>,
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct DeriveSupply has key {
+        dispatch_function: Option<FunctionInfo>
+    }
+
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    /// The store object that holds concurrent fungible asset balance.
+    struct ConcurrentFungibleBalance has key {
+        /// The balance of the fungible metadata.
+        balance: Aggregator<u64>,
+    }
+
+    /// FungibleAsset can be passed into function for type safety and to guarantee a specific amount.
+    /// FungibleAsset is ephemeral and cannot be stored directly. It must be deposited back into a store.
+    struct FungibleAsset {
+        metadata: Object<Metadata>,
+        amount: u64,
+    }
+
+    /// MintRef can be used to mint the fungible asset into an account's store.
+    struct MintRef has drop, store {
+        metadata: Object<Metadata>
+    }
+
+    /// TransferRef can be used to allow or disallow the owner of fungible assets from transferring the asset
+    /// and allow the holder of TransferRef to transfer fungible assets from any account.
+    struct TransferRef has drop, store {
+        metadata: Object<Metadata>
+    }
+
+    /// BurnRef can be used to burn fungible assets from a given holder account.
+    struct BurnRef has drop, store {
+        metadata: Object<Metadata>
+    }
+
+    /// MutateMetadataRef can be used to directly modify the fungible asset's Metadata.
+    struct MutateMetadataRef has drop, store {
+        metadata: Object<Metadata>
+    }
+
+    #[event]
+    /// Emitted when fungible assets are deposited into a store.
+    struct Deposit has drop, store {
+        store: address,
+        amount: u64,
+    }
+
+    #[event]
+    /// Emitted when fungible assets are withdrawn from a store.
+    struct Withdraw has drop, store {
+        store: address,
+        amount: u64,
+    }
+
+    #[event]
+    /// Emitted when a store's frozen status is updated.
+    struct Frozen has drop, store {
+        store: address,
+        frozen: bool,
+    }
+
+    inline fun default_to_concurrent_fungible_supply(): bool {
+        features::concurrent_fungible_assets_enabled()
+    }
+
+    inline fun allow_upgrade_to_concurrent_fungible_balance(): bool {
+        features::concurrent_fungible_balance_enabled()
+    }
+
+    inline fun default_to_concurrent_fungible_balance(): bool {
+        features::default_to_concurrent_fungible_balance_enabled()
+    }
+
+    /// Make an existing object fungible by adding the Metadata resource.
+    /// This returns the capabilities to mint, burn, and transfer.
+    /// maximum_supply defines the behavior of maximum supply when monitoring:
+    ///   - option::none(): Monitoring unlimited supply
+    ///     (width of the field - MAX_U128 is the implicit maximum supply)
+    ///     if option::some(MAX_U128) is used, it is treated as unlimited supply.
+    ///   - option::some(max): Monitoring fixed supply with `max` as the maximum supply.
+    public fun add_fungibility(
+        constructor_ref: &ConstructorRef,
+        maximum_supply: Option<u128>,
+        name: String,
+        symbol: String,
+        decimals: u8,
+        icon_uri: String,
+        project_uri: String,
+    ): Object<Metadata> {
+        assert!(!object::can_generate_delete_ref(constructor_ref), error::invalid_argument(EOBJECT_IS_DELETABLE));
+        let metadata_object_signer = &object::generate_signer(constructor_ref);
+        assert!(string::length(&name) <= MAX_NAME_LENGTH, error::out_of_range(ENAME_TOO_LONG));
+        assert!(string::length(&symbol) <= MAX_SYMBOL_LENGTH, error::out_of_range(ESYMBOL_TOO_LONG));
+        assert!(decimals <= MAX_DECIMALS, error::out_of_range(EDECIMALS_TOO_LARGE));
+        assert!(string::length(&icon_uri) <= MAX_URI_LENGTH, error::out_of_range(EURI_TOO_LONG));
+        assert!(string::length(&project_uri) <= MAX_URI_LENGTH, error::out_of_range(EURI_TOO_LONG));
+        move_to(metadata_object_signer,
+            Metadata {
+                name,
+                symbol,
+                decimals,
+                icon_uri,
+                project_uri,
+            }
+        );
+
+        if (default_to_concurrent_fungible_supply()) {
+            let unlimited = option::is_none(&maximum_supply);
+            move_to(metadata_object_signer, ConcurrentSupply {
+                current: if (unlimited) {
+                    aggregator_v2::create_unbounded_aggregator()
+                } else {
+                    aggregator_v2::create_aggregator(option::extract(&mut maximum_supply))
+                },
+            });
+        } else {
+            move_to(metadata_object_signer, Supply {
+                current: 0,
+                maximum: maximum_supply
+            });
+        };
+
+        object::object_from_constructor_ref<Metadata>(constructor_ref)
+    }
+
+    /// Set that only untransferable stores can be created for this fungible asset.
+    public fun set_untransferable(constructor_ref: &ConstructorRef) {
+        let metadata_addr = object::address_from_constructor_ref(constructor_ref);
+        assert!(exists<Metadata>(metadata_addr), error::not_found(EFUNGIBLE_METADATA_EXISTENCE));
+        let metadata_signer = &object::generate_signer(constructor_ref);
+        move_to(metadata_signer, Untransferable {});
+    }
+
+
+    #[view]
+    /// Returns true if the FA is untransferable.
+    public fun is_untransferable<T: key>(metadata: Object<T>): bool {
+        exists<Untransferable>(object::object_address(&metadata))
+    }
+
+    /// Create a fungible asset store whose transfer rule would be overloaded by the provided function.
+    public(friend) fun register_dispatch_functions(
+        constructor_ref: &ConstructorRef,
+        withdraw_function: Option<FunctionInfo>,
+        deposit_function: Option<FunctionInfo>,
+        derived_balance_function: Option<FunctionInfo>,
+    ) {
+        // Verify that caller type matches callee type so wrongly typed function cannot be registered.
+        option::for_each_ref(&withdraw_function, |withdraw_function| {
+            let dispatcher_withdraw_function_info = function_info::new_function_info_from_address(
+                @aptos_framework,
+                string::utf8(b"dispatchable_fungible_asset"),
+                string::utf8(b"dispatchable_withdraw"),
+            );
+
+            assert!(
+                function_info::check_dispatch_type_compatibility(
+                    &dispatcher_withdraw_function_info,
+                    withdraw_function
+                ),
+                error::invalid_argument(
+                    EWITHDRAW_FUNCTION_SIGNATURE_MISMATCH
+                )
+            );
+        });
+
+        option::for_each_ref(&deposit_function, |deposit_function| {
+            let dispatcher_deposit_function_info = function_info::new_function_info_from_address(
+                @aptos_framework,
+                string::utf8(b"dispatchable_fungible_asset"),
+                string::utf8(b"dispatchable_deposit"),
+            );
+            // Verify that caller type matches callee type so wrongly typed function cannot be registered.
+            assert!(
+                function_info::check_dispatch_type_compatibility(
+                    &dispatcher_deposit_function_info,
+                    deposit_function
+                ),
+                error::invalid_argument(
+                    EDEPOSIT_FUNCTION_SIGNATURE_MISMATCH
+                )
+            );
+        });
+
+        option::for_each_ref(&derived_balance_function, |balance_function| {
+            let dispatcher_derived_balance_function_info = function_info::new_function_info_from_address(
+                @aptos_framework,
+                string::utf8(b"dispatchable_fungible_asset"),
+                string::utf8(b"dispatchable_derived_balance"),
+            );
+            // Verify that caller type matches callee type so wrongly typed function cannot be registered.
+            assert!(
+                function_info::check_dispatch_type_compatibility(
+                    &dispatcher_derived_balance_function_info,
+                    balance_function
+                ),
+                error::invalid_argument(
+                    EDERIVED_BALANCE_FUNCTION_SIGNATURE_MISMATCH
+                )
+            );
+        });
+        register_dispatch_function_sanity_check(constructor_ref);
+        assert!(
+            !exists<DispatchFunctionStore>(
+                object::address_from_constructor_ref(constructor_ref)
+            ),
+            error::already_exists(EALREADY_REGISTERED)
+        );
+
+        let store_obj = &object::generate_signer(constructor_ref);
+
+        // Store the overload function hook.
+        move_to<DispatchFunctionStore>(
+            store_obj,
+            DispatchFunctionStore {
+                withdraw_function,
+                deposit_function,
+                derived_balance_function,
+            }
+        );
+    }
+
+    /// Define the derived supply dispatch with the provided function.
+    public(friend) fun register_derive_supply_dispatch_function(
+        constructor_ref: &ConstructorRef,
+        dispatch_function: Option<FunctionInfo>
+    ) {
+        // Verify that caller type matches callee type so wrongly typed function cannot be registered.
+        option::for_each_ref(&dispatch_function, |supply_function| {
+            let function_info = function_info::new_function_info_from_address(
+                @aptos_framework,
+                string::utf8(b"dispatchable_fungible_asset"),
+                string::utf8(b"dispatchable_derived_supply"),
+            );
+            // Verify that caller type matches callee type so wrongly typed function cannot be registered.
+            assert!(
+                function_info::check_dispatch_type_compatibility(
+                    &function_info,
+                    supply_function
+                ),
+                error::invalid_argument(
+                    EDERIVED_SUPPLY_FUNCTION_SIGNATURE_MISMATCH
+                )
+            );
+        });
+        register_dispatch_function_sanity_check(constructor_ref);
+        assert!(
+            !exists<DeriveSupply>(
+                object::address_from_constructor_ref(constructor_ref)
+            ),
+            error::already_exists(EALREADY_REGISTERED)
+        );
+
+
+        let store_obj = &object::generate_signer(constructor_ref);
+
+        // Store the overload function hook.
+        move_to<DeriveSupply>(
+            store_obj,
+            DeriveSupply {
+                dispatch_function
+            }
+        );
+    }
+
+    /// Check the requirements for registering a dispatchable function.
+    inline fun register_dispatch_function_sanity_check(
+        constructor_ref: &ConstructorRef,
+    )  {
+        // Cannot register hook for APT.
+        assert!(
+            object::address_from_constructor_ref(constructor_ref) != @aptos_fungible_asset,
+            error::permission_denied(EAPT_NOT_DISPATCHABLE)
+        );
+        assert!(
+            !object::can_generate_delete_ref(constructor_ref),
+            error::invalid_argument(EOBJECT_IS_DELETABLE)
+        );
+        assert!(
+            exists<Metadata>(
+                object::address_from_constructor_ref(constructor_ref)
+            ),
+            error::not_found(EFUNGIBLE_METADATA_EXISTENCE),
+        );
+    }
+
+    /// Creates a mint ref that can be used to mint fungible assets from the given fungible object's constructor ref.
+    /// This can only be called at object creation time as constructor_ref is only available then.
+    public fun generate_mint_ref(constructor_ref: &ConstructorRef): MintRef {
+        let metadata = object::object_from_constructor_ref<Metadata>(constructor_ref);
+        MintRef { metadata }
+    }
+
+    /// Creates a burn ref that can be used to burn fungible assets from the given fungible object's constructor ref.
+    /// This can only be called at object creation time as constructor_ref is only available then.
+    public fun generate_burn_ref(constructor_ref: &ConstructorRef): BurnRef {
+        let metadata = object::object_from_constructor_ref<Metadata>(constructor_ref);
+        BurnRef { metadata }
+    }
+
+    /// Creates a transfer ref that can be used to freeze/unfreeze/transfer fungible assets from the given fungible
+    /// object's constructor ref.
+    /// This can only be called at object creation time as constructor_ref is only available then.
+    public fun generate_transfer_ref(constructor_ref: &ConstructorRef): TransferRef {
+        let metadata = object::object_from_constructor_ref<Metadata>(constructor_ref);
+        TransferRef { metadata }
+    }
+
+    /// Creates a mutate metadata ref that can be used to change the metadata information of fungible assets from the
+    /// given fungible object's constructor ref.
+    /// This can only be called at object creation time as constructor_ref is only available then.
+    public fun generate_mutate_metadata_ref(constructor_ref: &ConstructorRef): MutateMetadataRef {
+        let metadata = object::object_from_constructor_ref<Metadata>(constructor_ref);
+        MutateMetadataRef { metadata }
+    }
+
+    #[view]
+    /// Get the current supply from the `metadata` object.
+    public fun supply<T: key>(metadata: Object<T>): Option<u128> acquires Supply, ConcurrentSupply {
+        let metadata_address = object::object_address(&metadata);
+        if (exists<ConcurrentSupply>(metadata_address)) {
+            let supply = borrow_global<ConcurrentSupply>(metadata_address);
+            option::some(aggregator_v2::read(&supply.current))
+        } else if (exists<Supply>(metadata_address)) {
+            let supply = borrow_global<Supply>(metadata_address);
+            option::some(supply.current)
+        } else {
+            option::none()
+        }
+    }
+
+    #[view]
+    /// Get the maximum supply from the `metadata` object.
+    /// If supply is unlimited (or set explicitly to MAX_U128), none is returned
+    public fun maximum<T: key>(metadata: Object<T>): Option<u128> acquires Supply, ConcurrentSupply {
+        let metadata_address = object::object_address(&metadata);
+        if (exists<ConcurrentSupply>(metadata_address)) {
+            let supply = borrow_global<ConcurrentSupply>(metadata_address);
+            let max_value = aggregator_v2::max_value(&supply.current);
+            if (max_value == MAX_U128) {
+                option::none()
+            } else {
+                option::some(max_value)
+            }
+        } else if (exists<Supply>(metadata_address)) {
+            let supply = borrow_global<Supply>(metadata_address);
+            supply.maximum
+        } else {
+            option::none()
+        }
+    }
+
+    #[view]
+    /// Get the name of the fungible asset from the `metadata` object.
+    public fun name<T: key>(metadata: Object<T>): String acquires Metadata {
+        borrow_fungible_metadata(&metadata).name
+    }
+
+    #[view]
+    /// Get the symbol of the fungible asset from the `metadata` object.
+    public fun symbol<T: key>(metadata: Object<T>): String acquires Metadata {
+        borrow_fungible_metadata(&metadata).symbol
+    }
+
+    #[view]
+    /// Get the decimals from the `metadata` object.
+    public fun decimals<T: key>(metadata: Object<T>): u8 acquires Metadata {
+        borrow_fungible_metadata(&metadata).decimals
+    }
+
+    #[view]
+    /// Get the icon uri from the `metadata` object.
+    public fun icon_uri<T: key>(metadata: Object<T>): String acquires Metadata {
+        borrow_fungible_metadata(&metadata).icon_uri
+    }
+
+    #[view]
+    /// Get the project uri from the `metadata` object.
+    public fun project_uri<T: key>(metadata: Object<T>): String acquires Metadata {
+        borrow_fungible_metadata(&metadata).project_uri
+    }
+
+    #[view]
+    /// Get the metadata struct from the `metadata` object.
+    public fun metadata<T: key>(metadata: Object<T>): Metadata acquires Metadata {
+        *borrow_fungible_metadata(&metadata)
+    }
+
+    #[view]
+    /// Return whether the provided address has a store initialized.
+    public fun store_exists(store: address): bool {
+        store_exists_inline(store)
+    }
+
+    /// Return whether the provided address has a store initialized.
+    inline fun store_exists_inline(store: address): bool {
+        exists<FungibleStore>(store)
+    }
+
+    /// Return whether the provided address has a concurrent fungible balance initialized,
+    /// at the fungible store address.
+    inline fun concurrent_fungible_balance_exists_inline(store: address): bool {
+        exists<ConcurrentFungibleBalance>(store)
+    }
+
+    /// Return the underlying metadata object
+    public fun metadata_from_asset(fa: &FungibleAsset): Object<Metadata> {
+        fa.metadata
+    }
+
+    #[view]
+    /// Return the underlying metadata object.
+    public fun store_metadata<T: key>(store: Object<T>): Object<Metadata> acquires FungibleStore {
+        borrow_store_resource(&store).metadata
+    }
+
+    /// Return the `amount` of a given fungible asset.
+    public fun amount(fa: &FungibleAsset): u64 {
+        fa.amount
+    }
+
+    #[view]
+    /// Get the balance of a given store.
+    public fun balance<T: key>(store: Object<T>): u64 acquires FungibleStore, ConcurrentFungibleBalance {
+        let store_addr = object::object_address(&store);
+        if (store_exists_inline(store_addr)) {
+            let store_balance = borrow_store_resource(&store).balance;
+            if (store_balance == 0 && concurrent_fungible_balance_exists_inline(store_addr)) {
+                let balance_resource = borrow_global<ConcurrentFungibleBalance>(store_addr);
+                aggregator_v2::read(&balance_resource.balance)
+            } else {
+                store_balance
+            }
+        } else {
+            0
+        }
+    }
+
+    #[view]
+    /// Check whether the balance of a given store is >= `amount`.
+    public fun is_balance_at_least<T: key>(store: Object<T>, amount: u64): bool acquires FungibleStore, ConcurrentFungibleBalance {
+        let store_addr = object::object_address(&store);
+        is_address_balance_at_least(store_addr, amount)
+    }
+
+    /// Check whether the balance of a given store is >= `amount`.
+    public(friend) fun is_address_balance_at_least(store_addr: address, amount: u64): bool acquires FungibleStore, ConcurrentFungibleBalance {
+        if (store_exists_inline(store_addr)) {
+            let store_balance = borrow_global<FungibleStore>(store_addr).balance;
+            if (store_balance == 0 && concurrent_fungible_balance_exists_inline(store_addr)) {
+                let balance_resource = borrow_global<ConcurrentFungibleBalance>(store_addr);
+                aggregator_v2::is_at_least(&balance_resource.balance, amount)
+            } else {
+                store_balance >= amount
+            }
+        } else {
+            amount == 0
+        }
+    }
+
+    #[view]
+    /// Return whether a store is frozen.
+    ///
+    /// If the store has not been created, we default to returning false so deposits can be sent to it.
+    public fun is_frozen<T: key>(store: Object<T>): bool acquires FungibleStore {
+        let store_addr = object::object_address(&store);
+        store_exists_inline(store_addr) && borrow_global<FungibleStore>(store_addr).frozen
+    }
+
+    #[view]
+    /// Return whether a fungible asset type is dispatchable.
+    public fun is_store_dispatchable<T: key>(store: Object<T>): bool acquires FungibleStore {
+        let fa_store = borrow_store_resource(&store);
+        let metadata_addr = object::object_address(&fa_store.metadata);
+        exists<DispatchFunctionStore>(metadata_addr)
+    }
+
+    public fun deposit_dispatch_function<T: key>(store: Object<T>): Option<FunctionInfo> acquires FungibleStore, DispatchFunctionStore {
+        let fa_store = borrow_store_resource(&store);
+        let metadata_addr = object::object_address(&fa_store.metadata);
+        if(exists<DispatchFunctionStore>(metadata_addr)) {
+            borrow_global<DispatchFunctionStore>(metadata_addr).deposit_function
+        } else {
+            option::none()
+        }
+    }
+
+    fun has_deposit_dispatch_function(metadata: Object<Metadata>): bool acquires DispatchFunctionStore {
+        let metadata_addr = object::object_address(&metadata);
+        // Short circuit on APT for better perf
+        if(metadata_addr != @aptos_fungible_asset && exists<DispatchFunctionStore>(metadata_addr)) {
+            option::is_some(&borrow_global<DispatchFunctionStore>(metadata_addr).deposit_function)
+        } else {
+            false
+        }
+    }
+
+    public fun withdraw_dispatch_function<T: key>(store: Object<T>): Option<FunctionInfo> acquires FungibleStore, DispatchFunctionStore {
+        let fa_store = borrow_store_resource(&store);
+        let metadata_addr = object::object_address(&fa_store.metadata);
+        if(exists<DispatchFunctionStore>(metadata_addr)) {
+            borrow_global<DispatchFunctionStore>(metadata_addr).withdraw_function
+        } else {
+            option::none()
+        }
+    }
+
+    fun has_withdraw_dispatch_function(metadata: Object<Metadata>): bool acquires DispatchFunctionStore {
+        let metadata_addr = object::object_address(&metadata);
+        // Short circuit on APT for better perf
+        if (metadata_addr != @aptos_fungible_asset && exists<DispatchFunctionStore>(metadata_addr)) {
+            option::is_some(&borrow_global<DispatchFunctionStore>(metadata_addr).withdraw_function)
+        } else {
+            false
+        }
+    }
+
+    public(friend) fun derived_balance_dispatch_function<T: key>(store: Object<T>): Option<FunctionInfo> acquires FungibleStore, DispatchFunctionStore {
+        let fa_store = borrow_store_resource(&store);
+        let metadata_addr = object::object_address(&fa_store.metadata);
+        if (exists<DispatchFunctionStore>(metadata_addr)) {
+            borrow_global<DispatchFunctionStore>(metadata_addr).derived_balance_function
+        } else {
+            option::none()
+        }
+    }
+
+    public(friend) fun derived_supply_dispatch_function<T: key>(metadata: Object<T>): Option<FunctionInfo> acquires DeriveSupply {
+        let metadata_addr = object::object_address(&metadata);
+        if (exists<DeriveSupply>(metadata_addr)) {
+            borrow_global<DeriveSupply>(metadata_addr).dispatch_function
+        } else {
+            option::none()
+        }
+    }
+
+    public fun asset_metadata(fa: &FungibleAsset): Object<Metadata> {
+        fa.metadata
+    }
+
+    /// Get the underlying metadata object from the `MintRef`.
+    public fun mint_ref_metadata(ref: &MintRef): Object<Metadata> {
+        ref.metadata
+    }
+
+    /// Get the underlying metadata object from the `TransferRef`.
+    public fun transfer_ref_metadata(ref: &TransferRef): Object<Metadata> {
+        ref.metadata
+    }
+
+    /// Get the underlying metadata object from the `BurnRef`.
+    public fun burn_ref_metadata(ref: &BurnRef): Object<Metadata> {
+        ref.metadata
+    }
+
+    /// Get the underlying metadata object from the `MutateMetadataRef`.
+    public fun object_from_metadata_ref(ref: &MutateMetadataRef): Object<Metadata> {
+        ref.metadata
+    }
+
+    /// 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 FungibleStore, DispatchFunctionStore, ConcurrentFungibleBalance {
+        let fa = withdraw(sender, from, amount);
+        deposit(to, fa);
+    }
+
+    /// Allow an object to hold a store for fungible assets.
+    /// Applications can use this to create multiple stores for isolating fungible assets for different purposes.
+    public fun create_store<T: key>(
+        constructor_ref: &ConstructorRef,
+        metadata: Object<T>,
+    ): Object<FungibleStore> {
+        let store_obj = &object::generate_signer(constructor_ref);
+        move_to(store_obj, FungibleStore {
+            metadata: object::convert(metadata),
+            balance: 0,
+            frozen: false,
+        });
+
+        if (is_untransferable(metadata)) {
+            object::set_untransferable(constructor_ref);
+        };
+
+        if (default_to_concurrent_fungible_balance()) {
+            move_to(store_obj, ConcurrentFungibleBalance {
+                balance: aggregator_v2::create_unbounded_aggregator(),
+            });
+        };
+
+        object::object_from_constructor_ref<FungibleStore>(constructor_ref)
+    }
+
+    /// Used to delete a store.  Requires the store to be completely empty prior to removing it
+    public fun remove_store(delete_ref: &DeleteRef) acquires FungibleStore, FungibleAssetEvents, ConcurrentFungibleBalance {
+        let store = &object::object_from_delete_ref<FungibleStore>(delete_ref);
+        let addr = object::object_address(store);
+        let FungibleStore { metadata: _, balance, frozen: _ }
+            = move_from<FungibleStore>(addr);
+        assert!(balance == 0, error::permission_denied(EBALANCE_IS_NOT_ZERO));
+
+        if (concurrent_fungible_balance_exists_inline(addr)) {
+            let ConcurrentFungibleBalance { balance } = move_from<ConcurrentFungibleBalance>(addr);
+            assert!(aggregator_v2::read(&balance) == 0, error::permission_denied(EBALANCE_IS_NOT_ZERO));
+        };
+
+        // Cleanup deprecated event handles if exist.
+        if (exists<FungibleAssetEvents>(addr)) {
+            let FungibleAssetEvents {
+                deposit_events,
+                withdraw_events,
+                frozen_events,
+            } = move_from<FungibleAssetEvents>(addr);
+            event::destroy_handle(deposit_events);
+            event::destroy_handle(withdraw_events);
+            event::destroy_handle(frozen_events);
+        };
+    }
+
+    /// Withdraw `amount` of the fungible asset from `store` by the owner.
+    public fun withdraw<T: key>(
+        owner: &signer,
+        store: Object<T>,
+        amount: u64,
+    ): FungibleAsset acquires FungibleStore, DispatchFunctionStore, ConcurrentFungibleBalance {
+        withdraw_sanity_check(owner, store, true);
+        withdraw_internal(object::object_address(&store), amount)
+    }
+
+    /// Check the permission for withdraw operation.
+    public(friend) fun withdraw_sanity_check<T: key>(
+        owner: &signer,
+        store: Object<T>,
+        abort_on_dispatch: bool,
+    ) acquires FungibleStore, DispatchFunctionStore {
+        assert!(object::owns(store, signer::address_of(owner)), error::permission_denied(ENOT_STORE_OWNER));
+        let fa_store = borrow_store_resource(&store);
+        assert!(
+            !abort_on_dispatch || !has_withdraw_dispatch_function(fa_store.metadata),
+            error::invalid_argument(EINVALID_DISPATCHABLE_OPERATIONS)
+        );
+        assert!(!fa_store.frozen, error::permission_denied(ESTORE_IS_FROZEN));
+    }
+
+    /// Deposit `amount` of the fungible asset to `store`.
+    public fun deposit_sanity_check<T: key>(
+        store: Object<T>,
+        abort_on_dispatch: bool
+    ) acquires FungibleStore, DispatchFunctionStore {
+        let fa_store = borrow_store_resource(&store);
+        assert!(
+            !abort_on_dispatch || !has_deposit_dispatch_function(fa_store.metadata),
+            error::invalid_argument(EINVALID_DISPATCHABLE_OPERATIONS)
+        );
+        assert!(!fa_store.frozen, error::permission_denied(ESTORE_IS_FROZEN));
+    }
+
+    /// Deposit `amount` of the fungible asset to `store`.
+    public fun deposit<T: key>(store: Object<T>, fa: FungibleAsset) acquires FungibleStore, DispatchFunctionStore, ConcurrentFungibleBalance {
+        deposit_sanity_check(store, true);
+        deposit_internal(object::object_address(&store), fa);
+    }
+
+    /// Mint the specified `amount` of the fungible asset.
+    public fun mint(ref: &MintRef, amount: u64): FungibleAsset acquires Supply, ConcurrentSupply {
+        let metadata = ref.metadata;
+        mint_internal(metadata, amount)
+    }
+
+    /// CAN ONLY BE CALLED BY coin.move for migration.
+    public(friend) fun mint_internal(
+        metadata: Object<Metadata>,
+        amount: u64
+    ): FungibleAsset acquires Supply, ConcurrentSupply {
+        increase_supply(&metadata, amount);
+        FungibleAsset {
+            metadata,
+            amount
+        }
+    }
+
+    /// Mint the specified `amount` of the fungible asset to a destination store.
+    public fun mint_to<T: key>(ref: &MintRef, store: Object<T>, amount: u64)
+    acquires FungibleStore, Supply, ConcurrentSupply, DispatchFunctionStore, ConcurrentFungibleBalance {
+        deposit_sanity_check(store, false);
+        deposit_internal(object::object_address(&store), mint(ref, amount));
+    }
+
+    /// Enable/disable a store's ability to do direct transfers of the fungible asset.
+    public fun set_frozen_flag<T: key>(
+        ref: &TransferRef,
+        store: Object<T>,
+        frozen: bool,
+    ) acquires FungibleStore {
+        assert!(
+            ref.metadata == store_metadata(store),
+            error::invalid_argument(ETRANSFER_REF_AND_STORE_MISMATCH),
+        );
+        set_frozen_flag_internal(store, frozen)
+    }
+
+    public(friend) fun set_frozen_flag_internal<T: key>(
+        store: Object<T>,
+        frozen: bool
+    ) acquires FungibleStore {
+        let store_addr = object::object_address(&store);
+        borrow_global_mut<FungibleStore>(store_addr).frozen = frozen;
+
+        event::emit(Frozen { store: store_addr, frozen });
+    }
+
+    /// Burns a fungible asset
+    public fun burn(ref: &BurnRef, fa: FungibleAsset) acquires Supply, ConcurrentSupply {
+        assert!(
+            ref.metadata == metadata_from_asset(&fa),
+            error::invalid_argument(EBURN_REF_AND_FUNGIBLE_ASSET_MISMATCH)
+        );
+        burn_internal(fa);
+    }
+
+    /// CAN ONLY BE CALLED BY coin.move for migration.
+    public(friend) fun burn_internal(
+        fa: FungibleAsset
+    ): u64 acquires Supply, ConcurrentSupply {
+        let FungibleAsset {
+            metadata,
+            amount
+        } = fa;
+        decrease_supply(&metadata, amount);
+        amount
+    }
+
+    /// Burn the `amount` of the fungible asset from the given store.
+    public fun burn_from<T: key>(
+        ref: &BurnRef,
+        store: Object<T>,
+        amount: u64
+    ) acquires FungibleStore, Supply, ConcurrentSupply, ConcurrentFungibleBalance {
+        // ref metadata match is checked in burn() call
+        burn(ref, withdraw_internal(object::object_address(&store), amount));
+    }
+
+    public(friend) fun address_burn_from(
+        ref: &BurnRef,
+        store_addr: address,
+        amount: u64
+    ) acquires FungibleStore, Supply, ConcurrentSupply, ConcurrentFungibleBalance {
+        // ref metadata match is checked in burn() call
+        burn(ref, withdraw_internal(store_addr, amount));
+    }
+
+    /// Withdraw `amount` of the fungible asset from the `store` ignoring `frozen`.
+    public fun withdraw_with_ref<T: key>(
+        ref: &TransferRef,
+        store: Object<T>,
+        amount: u64
+    ): FungibleAsset acquires FungibleStore, ConcurrentFungibleBalance {
+        assert!(
+            ref.metadata == store_metadata(store),
+            error::invalid_argument(ETRANSFER_REF_AND_STORE_MISMATCH),
+        );
+        withdraw_internal(object::object_address(&store), amount)
+    }
+
+    /// Deposit the fungible asset into the `store` ignoring `frozen`.
+    public fun deposit_with_ref<T: key>(
+        ref: &TransferRef,
+        store: Object<T>,
+        fa: FungibleAsset
+    ) acquires FungibleStore, ConcurrentFungibleBalance {
+        assert!(
+            ref.metadata == fa.metadata,
+            error::invalid_argument(ETRANSFER_REF_AND_FUNGIBLE_ASSET_MISMATCH)
+        );
+        deposit_internal(object::object_address(&store), fa);
+    }
+
+    /// Transfer `amount` of the fungible asset with `TransferRef` even it is frozen.
+    public fun transfer_with_ref<T: key>(
+        transfer_ref: &TransferRef,
+        from: Object<T>,
+        to: Object<T>,
+        amount: u64,
+    ) acquires FungibleStore, ConcurrentFungibleBalance {
+        let fa = withdraw_with_ref(transfer_ref, from, amount);
+        deposit_with_ref(transfer_ref, to, fa);
+    }
+
+    /// Mutate specified fields of the fungible asset's `Metadata`.
+    public fun mutate_metadata(
+        metadata_ref: &MutateMetadataRef,
+        name: Option<String>,
+        symbol: Option<String>,
+        decimals: Option<u8>,
+        icon_uri: Option<String>,
+        project_uri: Option<String>,
+    ) acquires Metadata {
+        let metadata_address = object::object_address(&metadata_ref.metadata);
+        let mutable_metadata = borrow_global_mut<Metadata>(metadata_address);
+
+        if (option::is_some(&name)){
+            mutable_metadata.name = option::extract(&mut name);
+        };
+        if (option::is_some(&symbol)){
+            mutable_metadata.symbol = option::extract(&mut symbol);
+        };
+        if (option::is_some(&decimals)){
+            mutable_metadata.decimals = option::extract(&mut decimals);
+        };
+        if (option::is_some(&icon_uri)){
+            mutable_metadata.icon_uri = option::extract(&mut icon_uri);
+        };
+        if (option::is_some(&project_uri)){
+            mutable_metadata.project_uri = option::extract(&mut project_uri);
+        };
+    }
+
+    /// Create a fungible asset with zero amount.
+    /// This can be useful when starting a series of computations where the initial value is 0.
+    public fun zero<T: key>(metadata: Object<T>): FungibleAsset {
+        FungibleAsset {
+            metadata: object::convert(metadata),
+            amount: 0,
+        }
+    }
+
+    /// Extract a given amount from the given fungible asset and return a new one.
+    public fun extract(fungible_asset: &mut FungibleAsset, amount: u64): FungibleAsset {
+        assert!(fungible_asset.amount >= amount, error::invalid_argument(EINSUFFICIENT_BALANCE));
+        fungible_asset.amount = fungible_asset.amount - amount;
+        FungibleAsset {
+            metadata: fungible_asset.metadata,
+            amount,
+        }
+    }
+
+    /// "Merges" the two given fungible assets. The fungible asset passed in as `dst_fungible_asset` will have a value
+    /// equal to the sum of the two (`dst_fungible_asset` and `src_fungible_asset`).
+    public fun merge(dst_fungible_asset: &mut FungibleAsset, src_fungible_asset: FungibleAsset) {
+        let FungibleAsset { metadata, amount } = src_fungible_asset;
+        assert!(metadata == dst_fungible_asset.metadata, error::invalid_argument(EFUNGIBLE_ASSET_MISMATCH));
+        dst_fungible_asset.amount = dst_fungible_asset.amount + amount;
+    }
+
+    /// Destroy an empty fungible asset.
+    public fun destroy_zero(fungible_asset: FungibleAsset) {
+        let FungibleAsset { amount, metadata: _ } = fungible_asset;
+        assert!(amount == 0, error::invalid_argument(EAMOUNT_IS_NOT_ZERO));
+    }
+
+    public(friend) fun deposit_internal(store_addr: address, fa: FungibleAsset) acquires FungibleStore, ConcurrentFungibleBalance {
+        let FungibleAsset { metadata, amount } = fa;
+        assert!(exists<FungibleStore>(store_addr), error::not_found(EFUNGIBLE_STORE_EXISTENCE));
+        let store = borrow_global_mut<FungibleStore>(store_addr);
+        assert!(metadata == store.metadata, error::invalid_argument(EFUNGIBLE_ASSET_AND_STORE_MISMATCH));
+
+        if (amount == 0) return;
+
+        if (store.balance == 0 && concurrent_fungible_balance_exists_inline(store_addr)) {
+            let balance_resource = borrow_global_mut<ConcurrentFungibleBalance>(store_addr);
+            aggregator_v2::add(&mut balance_resource.balance, amount);
+        } else {
+            store.balance = store.balance + amount;
+        };
+
+        event::emit(Deposit { store: store_addr, amount });
+    }
+
+    /// Extract `amount` of the fungible asset from `store`.
+    public(friend) fun withdraw_internal(
+        store_addr: address,
+        amount: u64,
+    ): FungibleAsset acquires FungibleStore, ConcurrentFungibleBalance {
+        assert!(exists<FungibleStore>(store_addr), error::not_found(EFUNGIBLE_STORE_EXISTENCE));
+
+        let store = borrow_global_mut<FungibleStore>(store_addr);
+        let metadata = store.metadata;
+        if (amount != 0) {
+            if (store.balance == 0 && concurrent_fungible_balance_exists_inline(store_addr)) {
+                let balance_resource = borrow_global_mut<ConcurrentFungibleBalance>(store_addr);
+                assert!(
+                    aggregator_v2::try_sub(&mut balance_resource.balance, amount),
+                    error::invalid_argument(EINSUFFICIENT_BALANCE)
+                );
+            } else {
+                assert!(store.balance >= amount, error::invalid_argument(EINSUFFICIENT_BALANCE));
+                store.balance = store.balance - amount;
+            };
+
+            event::emit<Withdraw>(Withdraw { store: store_addr, amount });
+        };
+        FungibleAsset { metadata, amount }
+    }
+
+    /// Increase the supply of a fungible asset by minting.
+    fun increase_supply<T: key>(metadata: &Object<T>, amount: u64) acquires Supply, ConcurrentSupply {
+        if (amount == 0) {
+            return
+        };
+        let metadata_address = object::object_address(metadata);
+
+        if (exists<ConcurrentSupply>(metadata_address)) {
+            let supply = borrow_global_mut<ConcurrentSupply>(metadata_address);
+            assert!(
+                aggregator_v2::try_add(&mut supply.current, (amount as u128)),
+                error::out_of_range(EMAX_SUPPLY_EXCEEDED)
+            );
+        } else if (exists<Supply>(metadata_address)) {
+            let supply = borrow_global_mut<Supply>(metadata_address);
+            if (option::is_some(&supply.maximum)) {
+                let max = *option::borrow_mut(&mut supply.maximum);
+                assert!(
+                    max - supply.current >= (amount as u128),
+                    error::out_of_range(EMAX_SUPPLY_EXCEEDED)
+                )
+            };
+            supply.current = supply.current + (amount as u128);
+        } else {
+            abort error::not_found(ESUPPLY_NOT_FOUND)
+        }
+    }
+
+    /// Decrease the supply of a fungible asset by burning.
+    fun decrease_supply<T: key>(metadata: &Object<T>, amount: u64) acquires Supply, ConcurrentSupply {
+        if (amount == 0) {
+            return
+        };
+        let metadata_address = object::object_address(metadata);
+
+        if (exists<ConcurrentSupply>(metadata_address)) {
+            let supply = borrow_global_mut<ConcurrentSupply>(metadata_address);
+
+            assert!(
+                aggregator_v2::try_sub(&mut supply.current, (amount as u128)),
+                error::out_of_range(ESUPPLY_UNDERFLOW)
+            );
+        } else if (exists<Supply>(metadata_address)) {
+            assert!(exists<Supply>(metadata_address), error::not_found(ESUPPLY_NOT_FOUND));
+            let supply = borrow_global_mut<Supply>(metadata_address);
+            assert!(
+                supply.current >= (amount as u128),
+                error::invalid_state(ESUPPLY_UNDERFLOW)
+            );
+            supply.current = supply.current - (amount as u128);
+        } else {
+            assert!(false, error::not_found(ESUPPLY_NOT_FOUND));
+        }
+    }
+
+    inline fun borrow_fungible_metadata<T: key>(
+        metadata: &Object<T>
+    ): &Metadata acquires Metadata {
+        let addr = object::object_address(metadata);
+        borrow_global<Metadata>(addr)
+    }
+
+    inline fun borrow_fungible_metadata_mut<T: key>(
+        metadata: &Object<T>
+    ): &mut Metadata acquires Metadata {
+        let addr = object::object_address(metadata);
+        borrow_global_mut<Metadata>(addr)
+    }
+
+    inline fun borrow_store_resource<T: key>(store: &Object<T>): &FungibleStore acquires FungibleStore {
+        let store_addr = object::object_address(store);
+        assert!(exists<FungibleStore>(store_addr), error::not_found(EFUNGIBLE_STORE_EXISTENCE));
+        borrow_global<FungibleStore>(store_addr)
+    }
+
+    public fun upgrade_to_concurrent(
+        ref: &ExtendRef,
+    ) acquires Supply {
+        let metadata_object_address = object::address_from_extend_ref(ref);
+        let metadata_object_signer = object::generate_signer_for_extending(ref);
+        assert!(
+            features::concurrent_fungible_assets_enabled(),
+            error::invalid_argument(ECONCURRENT_SUPPLY_NOT_ENABLED)
+        );
+        assert!(exists<Supply>(metadata_object_address), error::not_found(ESUPPLY_NOT_FOUND));
+        let Supply {
+            current,
+            maximum,
+        } = move_from<Supply>(metadata_object_address);
+
+        let unlimited = option::is_none(&maximum);
+        let supply = ConcurrentSupply {
+            current: if (unlimited) {
+                aggregator_v2::create_unbounded_aggregator_with_value(current)
+            }
+            else {
+                aggregator_v2::create_aggregator_with_value(current, option::extract(&mut maximum))
+            },
+        };
+        move_to(&metadata_object_signer, supply);
+    }
+
+    public entry fun upgrade_store_to_concurrent<T: key>(
+        owner: &signer,
+        store: Object<T>,
+    ) acquires FungibleStore {
+        assert!(object::owns(store, signer::address_of(owner)), error::permission_denied(ENOT_STORE_OWNER));
+        assert!(!is_frozen(store), error::invalid_argument(ESTORE_IS_FROZEN));
+        assert!(allow_upgrade_to_concurrent_fungible_balance(), error::invalid_argument(ECONCURRENT_BALANCE_NOT_ENABLED));
+        ensure_store_upgraded_to_concurrent_internal(object::object_address(&store));
+    }
+
+    /// Ensure a known `FungibleStore` has `ConcurrentFungibleBalance`.
+    fun ensure_store_upgraded_to_concurrent_internal(
+        fungible_store_address: address,
+    ) acquires FungibleStore {
+        if (exists<ConcurrentFungibleBalance>(fungible_store_address)) {
+            return
+        };
+        let store = borrow_global_mut<FungibleStore>(fungible_store_address);
+        let balance = aggregator_v2::create_unbounded_aggregator_with_value(store.balance);
+        store.balance = 0;
+        let object_signer = create_signer::create_signer(fungible_store_address);
+        move_to(&object_signer, ConcurrentFungibleBalance { balance });
+    }
+
+    #[test_only]
+    use aptos_framework::account;
+
+    #[test_only]
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+
+    struct TestToken has key {}
+
+    #[test_only]
+    public fun create_test_token(creator: &signer): (ConstructorRef, Object<TestToken>) {
+        account::create_account_for_test(signer::address_of(creator));
+        let creator_ref = object::create_named_object(creator, b"TEST");
+        let object_signer = object::generate_signer(&creator_ref);
+        move_to(&object_signer, TestToken {});
+
+        let token = object::object_from_constructor_ref<TestToken>(&creator_ref);
+        (creator_ref, token)
+    }
+
+    #[test_only]
+    public fun init_test_metadata(constructor_ref: &ConstructorRef): (MintRef, TransferRef, BurnRef, MutateMetadataRef) {
+        add_fungibility(
+            constructor_ref,
+            option::some(100) /* max supply */,
+            string::utf8(b"TEST"),
+            string::utf8(b"@@"),
+            0,
+            string::utf8(b"http://www.example.com/favicon.ico"),
+            string::utf8(b"http://www.example.com"),
+        );
+        let mint_ref = generate_mint_ref(constructor_ref);
+        let burn_ref = generate_burn_ref(constructor_ref);
+        let transfer_ref = generate_transfer_ref(constructor_ref);
+        let mutate_metadata_ref= generate_mutate_metadata_ref(constructor_ref);
+        (mint_ref, transfer_ref, burn_ref, mutate_metadata_ref)
+    }
+
+    #[test_only]
+    public fun create_fungible_asset(
+        creator: &signer
+    ): (MintRef, TransferRef, BurnRef, MutateMetadataRef, Object<Metadata>) {
+        let (creator_ref, token_object) = create_test_token(creator);
+        let (mint, transfer, burn, mutate_metadata) = init_test_metadata(&creator_ref);
+        (mint, transfer, burn, mutate_metadata, object::convert(token_object))
+    }
+
+    #[test_only]
+    public fun create_test_store<T: key>(owner: &signer, metadata: Object<T>): Object<FungibleStore> {
+        let owner_addr = signer::address_of(owner);
+        if (!account::exists_at(owner_addr)) {
+            account::create_account_for_test(owner_addr);
+        };
+        create_store(&object::create_object_from_account(owner), metadata)
+    }
+
+    #[test(creator = @0xcafe)]
+    fun test_metadata_basic_flow(creator: &signer) acquires Metadata, Supply, ConcurrentSupply {
+        let (creator_ref, metadata) = create_test_token(creator);
+        init_test_metadata(&creator_ref);
+        assert!(supply(metadata) == option::some(0), 1);
+        assert!(maximum(metadata) == option::some(100), 2);
+        assert!(name(metadata) == string::utf8(b"TEST"), 3);
+        assert!(symbol(metadata) == string::utf8(b"@@"), 4);
+        assert!(decimals(metadata) == 0, 5);
+        assert!(icon_uri(metadata) == string::utf8(b"http://www.example.com/favicon.ico"), 6);
+        assert!(project_uri(metadata) == string::utf8(b"http://www.example.com"), 7);
+
+        assert!(metadata(metadata) == Metadata {
+            name: string::utf8(b"TEST"),
+            symbol: string::utf8(b"@@"),
+            decimals: 0,
+            icon_uri: string::utf8(b"http://www.example.com/favicon.ico"),
+            project_uri: string::utf8(b"http://www.example.com"),
+        }, 8);
+
+        increase_supply(&metadata, 50);
+        assert!(supply(metadata) == option::some(50), 9);
+        decrease_supply(&metadata, 30);
+        assert!(supply(metadata) == option::some(20), 10);
+    }
+
+    #[test(creator = @0xcafe)]
+    #[expected_failure(abort_code = 0x20005, location = Self)]
+    fun test_supply_overflow(creator: &signer) acquires Supply, ConcurrentSupply {
+        let (creator_ref, metadata) = create_test_token(creator);
+        init_test_metadata(&creator_ref);
+        increase_supply(&metadata, 101);
+    }
+
+    #[test(creator = @0xcafe)]
+    fun test_create_and_remove_store(creator: &signer) acquires FungibleStore, FungibleAssetEvents, ConcurrentFungibleBalance {
+        let (_, _, _, _, metadata) = create_fungible_asset(creator);
+        let creator_ref = object::create_object_from_account(creator);
+        create_store(&creator_ref, metadata);
+        let delete_ref = object::generate_delete_ref(&creator_ref);
+        remove_store(&delete_ref);
+    }
+
+    #[test(creator = @0xcafe, aaron = @0xface)]
+    fun test_e2e_basic_flow(
+        creator: &signer,
+        aaron: &signer,
+    ) acquires FungibleStore, Supply, ConcurrentSupply, DispatchFunctionStore, ConcurrentFungibleBalance, Metadata {
+        let (mint_ref, transfer_ref, burn_ref, mutate_metadata_ref, test_token) = create_fungible_asset(creator);
+        let metadata = mint_ref.metadata;
+        let creator_store = create_test_store(creator, metadata);
+        let aaron_store = create_test_store(aaron, metadata);
+
+        assert!(supply(test_token) == option::some(0), 1);
+        // Mint
+        let fa = mint(&mint_ref, 100);
+        assert!(supply(test_token) == option::some(100), 2);
+        // Deposit
+        deposit(creator_store, fa);
+        // Withdraw
+        let fa = withdraw(creator, creator_store, 80);
+        assert!(supply(test_token) == option::some(100), 3);
+        deposit(aaron_store, fa);
+        // Burn
+        burn_from(&burn_ref, aaron_store, 30);
+        assert!(supply(test_token) == option::some(70), 4);
+        // Transfer
+        transfer(creator, creator_store, aaron_store, 10);
+        assert!(balance(creator_store) == 10, 5);
+        assert!(balance(aaron_store) == 60, 6);
+
+        set_frozen_flag(&transfer_ref, aaron_store, true);
+        assert!(is_frozen(aaron_store), 7);
+        // Mutate Metadata
+        mutate_metadata(
+            &mutate_metadata_ref,
+            option::some(string::utf8(b"mutated_name")),
+            option::some(string::utf8(b"mutated_symbol")),
+            option::none(),
+            option::none(),
+            option::none()
+        );
+        assert!(name(metadata) == string::utf8(b"mutated_name"), 8);
+        assert!(symbol(metadata) == string::utf8(b"mutated_symbol"), 9);
+        assert!(decimals(metadata) == 0, 10);
+        assert!(icon_uri(metadata) == string::utf8(b"http://www.example.com/favicon.ico"), 11);
+        assert!(project_uri(metadata) == string::utf8(b"http://www.example.com"), 12);
+    }
+
+    #[test(creator = @0xcafe)]
+    #[expected_failure(abort_code = 0x50003, location = Self)]
+    fun test_frozen(
+        creator: &signer
+    ) acquires FungibleStore, Supply, ConcurrentSupply, DispatchFunctionStore, ConcurrentFungibleBalance {
+        let (mint_ref, transfer_ref, _burn_ref, _mutate_metadata_ref,  _) = create_fungible_asset(creator);
+
+        let creator_store = create_test_store(creator, mint_ref.metadata);
+        let fa = mint(&mint_ref, 100);
+        set_frozen_flag(&transfer_ref, creator_store, true);
+        deposit(creator_store, fa);
+    }
+
+    #[test(creator = @0xcafe)]
+    #[expected_failure(abort_code = 0x50003, location = Self)]
+    fun test_mint_to_frozen(
+        creator: &signer
+    ) acquires FungibleStore, ConcurrentFungibleBalance, Supply, ConcurrentSupply, DispatchFunctionStore {
+        let (mint_ref, transfer_ref, _burn_ref, _mutate_metadata_ref, _) = create_fungible_asset(creator);
+
+        let creator_store = create_test_store(creator, mint_ref.metadata);
+        set_frozen_flag(&transfer_ref, creator_store, true);
+        mint_to(&mint_ref, creator_store, 100);
+    }
+
+    #[test(creator = @0xcafe)]
+    #[expected_failure(abort_code = 0x50003, location = aptos_framework::object)]
+    fun test_untransferable(
+        creator: &signer
+    ) {
+        let (creator_ref, _) = create_test_token(creator);
+        let (mint_ref, _, _, _) = init_test_metadata(&creator_ref);
+        set_untransferable(&creator_ref);
+
+        let creator_store = create_test_store(creator, mint_ref.metadata);
+        object::transfer(creator, creator_store, @0x456);
+    }
+
+    #[test(creator = @0xcafe, aaron = @0xface)]
+    fun test_transfer_with_ref(
+        creator: &signer,
+        aaron: &signer,
+    ) acquires FungibleStore, Supply, ConcurrentSupply, ConcurrentFungibleBalance {
+        let (mint_ref, transfer_ref, _burn_ref, _mutate_metadata_ref, _) = create_fungible_asset(creator);
+        let metadata = mint_ref.metadata;
+        let creator_store = create_test_store(creator, metadata);
+        let aaron_store = create_test_store(aaron, metadata);
+
+        let fa = mint(&mint_ref, 100);
+        set_frozen_flag(&transfer_ref, creator_store, true);
+        set_frozen_flag(&transfer_ref, aaron_store, true);
+        deposit_with_ref(&transfer_ref, creator_store, fa);
+        transfer_with_ref(&transfer_ref, creator_store, aaron_store, 80);
+        assert!(balance(creator_store) == 20, 1);
+        assert!(balance(aaron_store) == 80, 2);
+        assert!(!!is_frozen(creator_store), 3);
+        assert!(!!is_frozen(aaron_store), 4);
+    }
+
+    #[test(creator = @0xcafe)]
+    fun test_mutate_metadata(
+        creator: &signer
+    ) acquires Metadata {
+        let (mint_ref, _transfer_ref, _burn_ref, mutate_metadata_ref, _) = create_fungible_asset(creator);
+        let metadata = mint_ref.metadata;
+
+        mutate_metadata(
+            &mutate_metadata_ref,
+            option::some(string::utf8(b"mutated_name")),
+            option::some(string::utf8(b"mutated_symbol")),
+            option::some(10),
+            option::some(string::utf8(b"http://www.mutated-example.com/favicon.ico")),
+            option::some(string::utf8(b"http://www.mutated-example.com"))
+        );
+        assert!(name(metadata) == string::utf8(b"mutated_name"), 1);
+        assert!(symbol(metadata) == string::utf8(b"mutated_symbol"), 2);
+        assert!(decimals(metadata) == 10, 3);
+        assert!(icon_uri(metadata) == string::utf8(b"http://www.mutated-example.com/favicon.ico"), 4);
+        assert!(project_uri(metadata) == string::utf8(b"http://www.mutated-example.com"), 5);
+    }
+
+    #[test(creator = @0xcafe)]
+    fun test_partial_mutate_metadata(
+        creator: &signer
+    ) acquires Metadata {
+        let (mint_ref, _transfer_ref, _burn_ref, mutate_metadata_ref, _) = create_fungible_asset(creator);
+        let metadata = mint_ref.metadata;
+
+        mutate_metadata(
+            &mutate_metadata_ref,
+            option::some(string::utf8(b"mutated_name")),
+            option::some(string::utf8(b"mutated_symbol")),
+            option::none(),
+            option::none(),
+            option::none()
+        );
+        assert!(name(metadata) == string::utf8(b"mutated_name"), 8);
+        assert!(symbol(metadata) == string::utf8(b"mutated_symbol"), 9);
+        assert!(decimals(metadata) == 0, 10);
+        assert!(icon_uri(metadata) == string::utf8(b"http://www.example.com/favicon.ico"), 11);
+        assert!(project_uri(metadata) == string::utf8(b"http://www.example.com"), 12);
+    }
+
+    #[test(creator = @0xcafe)]
+    fun test_merge_and_exact(creator: &signer) acquires Supply, ConcurrentSupply {
+        let (mint_ref, _transfer_ref, burn_ref, _mutate_metadata_ref, _) = create_fungible_asset(creator);
+        let fa = mint(&mint_ref, 100);
+        let cash = extract(&mut fa, 80);
+        assert!(fa.amount == 20, 1);
+        assert!(cash.amount == 80, 2);
+        let more_cash = extract(&mut fa, 20);
+        destroy_zero(fa);
+        merge(&mut cash, more_cash);
+        assert!(cash.amount == 100, 3);
+        burn(&burn_ref, cash);
+    }
+
+    #[test(creator = @0xcafe)]
+    #[expected_failure(abort_code = 0x10012, location = Self)]
+    fun test_add_fungibility_to_deletable_object(creator: &signer) {
+        account::create_account_for_test(signer::address_of(creator));
+        let creator_ref = &object::create_object_from_account(creator);
+        init_test_metadata(creator_ref);
+    }
+
+    #[test(creator = @0xcafe, aaron = @0xface)]
+    #[expected_failure(abort_code = 0x10006, location = Self)]
+    fun test_fungible_asset_mismatch_when_merge(creator: &signer, aaron: &signer) {
+        let (_, _, _, _, metadata1) = create_fungible_asset(creator);
+        let (_, _, _, _, metadata2) = create_fungible_asset(aaron);
+        let base = FungibleAsset {
+            metadata: metadata1,
+            amount: 1,
+        };
+        let addon = FungibleAsset {
+            metadata: metadata2,
+            amount: 1
+        };
+        merge(&mut base, addon);
+        let FungibleAsset {
+            metadata: _,
+            amount: _
+        } = base;
+    }
+
+    #[test(fx = @aptos_framework, creator = @0xcafe)]
+    fun test_fungible_asset_upgrade(fx: &signer, creator: &signer) acquires Supply, ConcurrentSupply, FungibleStore, ConcurrentFungibleBalance {
+        let supply_feature = features::get_concurrent_fungible_assets_feature();
+        let balance_feature = features::get_concurrent_fungible_balance_feature();
+        let default_balance_feature = features::get_default_to_concurrent_fungible_balance_feature();
+
+        features::change_feature_flags_for_testing(fx, vector[], vector[supply_feature, balance_feature, default_balance_feature]);
+
+        let (creator_ref, token_object) = create_test_token(creator);
+        let (mint_ref, transfer_ref, _burn, _mutate_metadata_ref) = init_test_metadata(&creator_ref);
+        let test_token = object::convert<TestToken, Metadata>(token_object);
+        assert!(exists<Supply>(object::object_address(&test_token)), 1);
+        assert!(!exists<ConcurrentSupply>(object::object_address(&test_token)), 2);
+        let creator_store = create_test_store(creator, test_token);
+        assert!(exists<FungibleStore>(object::object_address(&creator_store)), 3);
+        assert!(!exists<ConcurrentFungibleBalance>(object::object_address(&creator_store)), 4);
+
+        let fa = mint(&mint_ref, 30);
+        assert!(supply(test_token) == option::some(30), 5);
+
+        deposit_with_ref(&transfer_ref, creator_store, fa);
+        assert!(exists<FungibleStore>(object::object_address(&creator_store)), 13);
+        assert!(borrow_store_resource(&creator_store).balance == 30, 14);
+        assert!(!exists<ConcurrentFungibleBalance>(object::object_address(&creator_store)), 15);
+
+        features::change_feature_flags_for_testing(fx, vector[supply_feature, balance_feature], vector[default_balance_feature]);
+
+        let extend_ref = object::generate_extend_ref(&creator_ref);
+        // manual conversion of supply
+        upgrade_to_concurrent(&extend_ref);
+        assert!(!exists<Supply>(object::object_address(&test_token)), 6);
+        assert!(exists<ConcurrentSupply>(object::object_address(&test_token)), 7);
+
+        // assert conversion of balance
+        upgrade_store_to_concurrent(creator, creator_store);
+        let fb = withdraw_with_ref(&transfer_ref, creator_store, 20);
+        // both store and new balance need to exist. Old balance should be 0.
+        assert!(exists<FungibleStore>(object::object_address(&creator_store)), 9);
+        assert!(borrow_store_resource(&creator_store).balance == 0, 10);
+        assert!(exists<ConcurrentFungibleBalance>(object::object_address(&creator_store)), 11);
+        assert!(aggregator_v2::read(&borrow_global<ConcurrentFungibleBalance>(object::object_address(&creator_store)).balance) == 10, 12);
+
+        deposit_with_ref(&transfer_ref, creator_store, fb);
+    }
+
+    #[test(fx = @aptos_framework, creator = @0xcafe)]
+    fun test_fungible_asset_default_concurrent(fx: &signer, creator: &signer) acquires Supply, ConcurrentSupply, FungibleStore, ConcurrentFungibleBalance {
+        let supply_feature = features::get_concurrent_fungible_assets_feature();
+        let balance_feature = features::get_concurrent_fungible_balance_feature();
+        let default_balance_feature = features::get_default_to_concurrent_fungible_balance_feature();
+
+        features::change_feature_flags_for_testing(fx, vector[supply_feature, balance_feature, default_balance_feature], vector[]);
+
+        let (creator_ref, token_object) = create_test_token(creator);
+        let (mint_ref, transfer_ref, _burn, _mutate_metadata_ref) = init_test_metadata(&creator_ref);
+        let test_token = object::convert<TestToken, Metadata>(token_object);
+        assert!(!exists<Supply>(object::object_address(&test_token)), 1);
+        assert!(exists<ConcurrentSupply>(object::object_address(&test_token)), 2);
+        let creator_store = create_test_store(creator, test_token);
+        assert!(exists<FungibleStore>(object::object_address(&creator_store)), 3);
+        assert!(exists<ConcurrentFungibleBalance>(object::object_address(&creator_store)), 4);
+
+        let fa = mint(&mint_ref, 30);
+        assert!(supply(test_token) == option::some(30), 5);
+
+        deposit_with_ref(&transfer_ref, creator_store, fa);
+
+        assert!(exists<FungibleStore>(object::object_address(&creator_store)), 9);
+        assert!(borrow_store_resource(&creator_store).balance == 0, 10);
+        assert!(exists<ConcurrentFungibleBalance>(object::object_address(&creator_store)), 11);
+        assert!(aggregator_v2::read(&borrow_global<ConcurrentFungibleBalance>(object::object_address(&creator_store)).balance) == 30, 12);
+    }
+
+    #[deprecated]
+    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
+    struct FungibleAssetEvents has key {
+        deposit_events: event::EventHandle<DepositEvent>,
+        withdraw_events: event::EventHandle<WithdrawEvent>,
+        frozen_events: event::EventHandle<FrozenEvent>,
+    }
+
+    #[deprecated]
+    struct DepositEvent has drop, store {
+        amount: u64,
+    }
+
+    #[deprecated]
+    struct WithdrawEvent has drop, store {
+        amount: u64,
+    }
+
+    #[deprecated]
+    struct FrozenEvent has drop, store {
+        frozen: bool,
+    }
+}