create-dubhe 0.1.13 → 1.2.0-pre.51

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/fungible_asset.move

@@ -1,1391 +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.
-module initia_std::fungible_asset {
-    use initia_std::event;
-    use initia_std::object::{Self, Object, ConstructorRef, DeleteRef, ExtendRef};
-    use initia_std::function_info::{Self, FunctionInfo};
-
-    use std::error;
-    use std::option::{Self, Option};
-    use std::signer;
-    use std::string::{Self, String};
-    use std::account;
-
-    friend initia_std::primary_fungible_store;
-    friend initia_std::dispatchable_fungible_asset;
-
-    /// 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 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 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;
-    /// Provided derived_supply function type doesn't meet the signature requirement.
-    const EDERIVED_SUPPLY_FUNCTION_SIGNATURE_MISMATCH: u64 = 33;
-    /// Module account store cannot be manipulated.
-    const ECONNOT_MANIPULATE_MODULE_ACCOUNT_STORE: u64 = 91;
-    /// Deposit to a blocked account is not allowed._
-    const ECANNOT_DEPOSIT_TO_BLOCKED_ACCOUNT: u64 = 92;
-
-    //
-    // Constants
-    //
-
-    /// Increase name length to 128 due to cosmos spec.
-    const MAX_NAME_LENGTH: u64 = 128;
-    /// Increase symbol length to 128 due to cosmos spec.
-    const MAX_SYMBOL_LENGTH: u64 = 128;
-    const MAX_DECIMALS: u8 = 32;
-    const MAX_URI_LENGTH: u64 = 512;
-
-    /// Maximum possible coin supply.
-    const MAX_U128: u128 = 340282366920938463463374607431768211455;
-
-    struct Supply has key {
-        current: u128,
-        // option::none() means unlimited supply.
-        maximum: Option<u128>
-    }
-
-    /// 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
-    }
-
-    /// 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
-    }
-
-    /// 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
-    }
-
-    struct DispatchFunctionStore has key {
-        withdraw_function: Option<FunctionInfo>,
-        deposit_function: Option<FunctionInfo>,
-        derived_balance_function: Option<FunctionInfo>
-    }
-
-    struct DeriveSupply has key {
-        dispatch_function: Option<FunctionInfo>
-    }
-
-    /// 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 DepositEvent has drop, store {
-        store_addr: address,
-        metadata_addr: address,
-        amount: u64
-    }
-
-    #[event]
-    /// Emitted when fungible assets are withdrawn from a store.
-    struct WithdrawEvent has drop, store {
-        store_addr: address,
-        metadata_addr: address,
-        amount: u64
-    }
-
-    #[event]
-    /// Emitted when a store's frozen status is updated.
-    struct FrozenEvent has drop, store {
-        store_addr: address,
-        metadata_addr: address,
-        frozen: bool
-    }
-
-    #[event]
-    /// Emitted when fungible assets are burnt.
-    struct BurnEvent has drop, store {
-        metadata_addr: address,
-        amount: u64
-    }
-
-    #[event]
-    /// Emitted when fungible assets are minted.
-    struct MintEvent has drop, store {
-        metadata_addr: address,
-        amount: u64
-    }
-
-    /// 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
-    ///   - 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);
-
-        // metadata validations
-        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)
-        );
-
-        // store metadata
-        move_to(
-            metadata_object_signer,
-            Metadata { name, symbol, decimals, icon_uri, project_uri }
-        );
-
-        // store supply
-        move_to(
-            metadata_object_signer,
-            Supply { current: 0, maximum: maximum_supply }
-        );
-
-        // return metadata object
-        object::object_from_constructor_ref<Metadata>(constructor_ref)
-    }
-
-    /// 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(
-                        @initia_std,
-                        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(
-                        @initia_std,
-                        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(
-                        @initia_std,
-                        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(
-                        @initia_std,
-                        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) != @initia_std,
-            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]
-    /// Return true if given address has Metadata else return false
-    public fun is_fungible_asset(metadata_addr: address): bool {
-        exists<Metadata>(metadata_addr)
-    }
-
-    #[view]
-    /// Get the current supply from the `metadata` object.
-    public fun supply<T: key>(metadata: Object<T>): Option<u128> acquires Supply {
-        let metadata_address = object::object_address(&metadata);
-        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.
-    public fun maximum<T: key>(metadata: Object<T>): Option<u128> acquires Supply {
-        let metadata_address = object::object_address(&metadata);
-        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 {
-        metadata(metadata).symbol
-    }
-
-    #[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 {
-        let md = *borrow_fungible_metadata(&metadata);
-        if (object::is_owner(metadata, @initia_std)
-            && md.symbol == string::utf8(b"uinit")) {
-            md.symbol = string::utf8(b"INIT");
-            md.decimals = 6;
-        };
-
-        md
-    }
-
-    #[view]
-    /// Get the decimals from the `metadata` object.
-    public fun decimals<T: key>(metadata: Object<T>): u8 acquires Metadata {
-        metadata(metadata).decimals
-    }
-
-    #[view]
-    /// Return whether the provided address has a store initialized.
-    public fun store_exists(store: address): bool {
-        exists<FungibleStore>(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 {
-        if (store_exists(object::object_address(&store))) {
-            borrow_store_resource(&store).balance
-        } else { 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 {
-        store_exists(object::object_address(&store))
-            && borrow_store_resource(&store).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 != @initia_std
-            && 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 != @initia_std
-            && 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 {
-        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 }
-        );
-
-        object::object_from_constructor_ref<FungibleStore>(constructor_ref)
-    }
-
-    /// 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_with_extend_ref<T: key>(
-        extend_ref: &ExtendRef, metadata: Object<T>
-    ): Object<FungibleStore> {
-        let store_obj = &object::generate_signer_for_extending(extend_ref);
-        move_to(
-            store_obj,
-            FungibleStore { metadata: object::convert(metadata), balance: 0, frozen: false }
-        );
-
-        let obj_addr = object::address_from_extend_ref(extend_ref);
-        object::address_to_object<FungibleStore>(obj_addr)
-    }
-
-    /// 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 {
-        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)
-        );
-    }
-
-    /// 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));
-
-        // cannot deposit to blocked account
-        let store_addr = object::object_address(&store);
-        assert!(
-            !is_blocked_store_addr(store_addr),
-            error::invalid_argument(ECANNOT_DEPOSIT_TO_BLOCKED_ACCOUNT)
-        );
-    }
-
-    /// 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 {
-        withdraw_sanity_check(owner, store, true);
-        withdraw_internal(object::object_address(&store), amount)
-    }
-
-    /// Deposit `amount` of the fungible asset to `store`.
-    public fun deposit<T: key>(
-        store: Object<T>, fa: FungibleAsset
-    ) acquires FungibleStore, DispatchFunctionStore {
-        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 {
-        let metadata = ref.metadata;
-        if (amount == 0) return zero(metadata);
-
-        increase_supply(metadata, amount);
-
-        // emit event
-        let metadata_addr = object::object_address(&metadata);
-        event::emit(MintEvent { metadata_addr, 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, DispatchFunctionStore {
-        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)
-        );
-
-        let metadata_addr = object::object_address(&ref.metadata);
-        let store_addr = object::object_address(&store);
-
-        // cannot freeze module account store
-        assert!(
-            !is_module_account_store_addr(store_addr),
-            error::invalid_argument(ECONNOT_MANIPULATE_MODULE_ACCOUNT_STORE)
-        );
-
-        borrow_global_mut<FungibleStore>(store_addr).frozen = frozen;
-
-        // emit event
-        event::emit(FrozenEvent { store_addr, metadata_addr, frozen });
-    }
-
-    /// Burns a fungible asset
-    public fun burn(ref: &BurnRef, fa: FungibleAsset) acquires Supply {
-        let FungibleAsset { metadata, amount } = fa;
-        assert!(
-            ref.metadata == metadata,
-            error::invalid_argument(EBURN_REF_AND_FUNGIBLE_ASSET_MISMATCH)
-        );
-        decrease_supply(metadata, amount);
-
-        // emit event
-        let metadata_addr = object::object_address(&metadata);
-        event::emit(BurnEvent { metadata_addr, 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 {
-        let metadata = ref.metadata;
-        assert!(
-            metadata == store_metadata(store),
-            error::invalid_argument(EBURN_REF_AND_STORE_MISMATCH)
-        );
-
-        let store_addr = object::object_address(&store);
-
-        // cannot burn module account funds
-        assert!(
-            !is_module_account_store_addr(store_addr),
-            error::invalid_argument(ECONNOT_MANIPULATE_MODULE_ACCOUNT_STORE)
-        );
-
-        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 {
-        assert!(
-            ref.metadata == store_metadata(store),
-            error::invalid_argument(ETRANSFER_REF_AND_STORE_MISMATCH)
-        );
-
-        // cannot withdraw module account funds
-        let store_addr = object::object_address(&store);
-        assert!(
-            !is_module_account_store_addr(store_addr),
-            error::invalid_argument(ECONNOT_MANIPULATE_MODULE_ACCOUNT_STORE)
-        );
-
-        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 {
-        assert!(
-            ref.metadata == fa.metadata,
-            error::invalid_argument(ETRANSFER_REF_AND_FUNGIBLE_ASSET_MISMATCH)
-        );
-
-        // cannot deposit to blocked account
-        let store_addr = object::object_address(&store);
-        assert!(
-            !is_blocked_store_addr(store_addr),
-            error::invalid_argument(ECANNOT_DEPOSIT_TO_BLOCKED_ACCOUNT)
-        );
-
-        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 {
-        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);
-        };
-    }
-
-    /// 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.
-    ///
-    /// This function is only callable by the chain.
-    public(friend) fun sudo_transfer<T: key>(
-        sender: &signer,
-        from: Object<T>,
-        to: Object<T>,
-        amount: u64
-    ) acquires FungibleStore, DispatchFunctionStore {
-        let fa = withdraw(sender, from, amount);
-        sudo_deposit(to, fa);
-    }
-
-    /// Deposit `amount` of the fungible asset to `store`.
-    ///
-    /// This function is only callable by the chain.
-    public(friend) fun sudo_deposit<T: key>(
-        store: Object<T>, fa: FungibleAsset
-    ) acquires FungibleStore {
-        assert!(
-            !is_frozen(store),
-            error::invalid_argument(ESTORE_IS_FROZEN)
-        );
-
-        deposit_internal(object::object_address(&store), fa);
-    }
-
-    /// 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 {
-        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;
-
-        store.balance = store.balance + amount;
-
-        // emit event
-        let metadata_addr = object::object_address(&metadata);
-        event::emit(DepositEvent { store_addr, metadata_addr, amount });
-    }
-
-    /// Extract `amount` of the fungible asset from `store`.
-    public(friend) fun withdraw_internal(
-        store_addr: address, amount: u64
-    ): FungibleAsset acquires FungibleStore {
-        let store = borrow_global_mut<FungibleStore>(store_addr);
-        let metadata = store.metadata;
-        if (amount == 0) return zero(metadata);
-
-        assert!(
-            store.balance >= amount,
-            error::invalid_argument(EINSUFFICIENT_BALANCE)
-        );
-        store.balance = store.balance - amount;
-
-        // emit event
-        let metadata_addr = object::object_address(&metadata);
-        event::emit(WithdrawEvent { store_addr, metadata_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 {
-        if (amount == 0) return;
-
-        let metadata_address = object::object_address(&metadata);
-        assert!(
-            exists<Supply>(metadata_address),
-            error::not_found(ESUPPLY_NOT_FOUND)
-        );
-        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);
-    }
-
-    /// Decrease the supply of a fungible asset by burning.
-    fun decrease_supply<T: key>(metadata: Object<T>, amount: u64) acquires Supply {
-        if (amount == 0) return;
-
-        let metadata_address = object::object_address(&metadata);
-        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);
-    }
-
-    fun is_module_account_store_addr(store_addr: address): bool {
-        let fungible_store = object::address_to_object<FungibleStore>(store_addr);
-        let owner_addr = object::owner(fungible_store);
-        let (found, info) = account::get_account_info(owner_addr);
-        found && account::is_module_account_with_info(&info)
-    }
-
-    fun is_blocked_store_addr(store_addr: address): bool {
-        let fungible_store = object::address_to_object<FungibleStore>(store_addr);
-        let owner_addr = object::owner(fungible_store);
-        let (found, info) = account::get_account_info(owner_addr);
-        found && account::is_blocked_with_info(&info)
-    }
-
-    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 {
-        borrow_global<FungibleStore>(object::object_address(store))
-    }
-
-    #[test_only]
-    struct TestToken has key {}
-
-    #[test_only]
-    public fun create_test_token(creator: &signer): (ConstructorRef, Object<TestToken>) {
-        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);
-        create_store(
-            &object::create_object(owner_addr, true),
-            metadata
-        )
-    }
-
-    #[test(creator = @0xcafe)]
-    fun test_metadata_basic_flow(creator: &signer) acquires Metadata, Supply {
-        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);
-
-        increase_supply(metadata, 50);
-        assert!(supply(metadata) == option::some(50), 6);
-        decrease_supply(metadata, 30);
-        assert!(supply(metadata) == option::some(20), 7);
-    }
-
-    #[test(creator = @0xcafe)]
-    #[expected_failure(abort_code = 0x20005, location = Self)]
-    fun test_supply_overflow(creator: &signer) acquires Supply {
-        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 {
-        let (_, _, _, _, metadata) = create_fungible_asset(creator);
-        let creator_ref = object::create_object(signer::address_of(creator), true);
-        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, DispatchFunctionStore, 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, 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);
-        let fa = mint(&mint_ref, 100);
-        set_frozen_flag(&transfer_ref, creator_store, true);
-        deposit(creator_store, fa);
-    }
-
-    #[test(creator = @0xcafe, aaron = @0xface)]
-    fun test_transfer_with_ref(creator: &signer, aaron: &signer) acquires FungibleStore, Supply {
-        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_merge_and_exact(creator: &signer) acquires Supply {
-        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) {
-        let creator_ref = &object::create_object(signer::address_of(creator), true);
-        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(creator = @0xcafe, module_acc = @0x123)]
-    #[expected_failure(abort_code = 0x1005B, location = Self)]
-    fun test_freeze_module_account_store(
-        creator: &signer, module_acc: &signer
-    ) acquires FungibleStore {
-        let (mint_ref, transfer_ref, _burn_ref, _mutate_metadata_ref, _) =
-            create_fungible_asset(creator);
-        let metadata = mint_ref.metadata;
-
-        let module_acc_store = create_test_store(module_acc, metadata);
-        account::set_account_info(signer::address_of(module_acc), 10, 0, 3, false);
-
-        set_frozen_flag(&transfer_ref, module_acc_store, true);
-    }
-
-    #[test(creator = @0xcafe, module_acc = @0x123)]
-    #[expected_failure(abort_code = 0x1005B, location = Self)]
-    fun test_burn_module_account_funds(
-        creator: &signer, module_acc: &signer
-    ) acquires FungibleStore, Supply, DispatchFunctionStore {
-        let (mint_ref, _transfer_ref, burn_ref, _mutate_metadata_ref, _) =
-            create_fungible_asset(creator);
-        let metadata = mint_ref.metadata;
-
-        let module_acc_store = create_test_store(module_acc, metadata);
-        account::set_account_info(signer::address_of(module_acc), 10, 0, 3, false);
-
-        let fa = mint(&mint_ref, 100);
-        deposit(module_acc_store, fa);
-        burn_from(&burn_ref, module_acc_store, 30);
-    }
-
-    #[test(creator = @0xcafe, module_acc = @0x123)]
-    #[expected_failure(abort_code = 0x1005B, location = Self)]
-    fun test_withdraw_module_account_funds_with_ref(
-        creator: &signer, module_acc: &signer
-    ) acquires FungibleStore, Supply, DispatchFunctionStore {
-        let (mint_ref, transfer_ref, _burn_ref, _mutate_metadata_ref, _) =
-            create_fungible_asset(creator);
-        let metadata = mint_ref.metadata;
-
-        let module_acc_store = create_test_store(module_acc, metadata);
-        account::set_account_info(signer::address_of(module_acc), 10, 0, 3, false);
-
-        let fa = mint(&mint_ref, 100);
-        deposit(module_acc_store, fa);
-        let fa = withdraw_with_ref(&transfer_ref, module_acc_store, 30);
-        deposit(module_acc_store, fa);
-    }
-
-    #[test(creator = @0xcafe, blocked_acc = @0x123)]
-    #[expected_failure(abort_code = 0x1005C, location = Self)]
-    fun test_deposit_blocked_account(
-        creator: &signer, blocked_acc: &signer
-    ) acquires FungibleStore, Supply, DispatchFunctionStore {
-        let (mint_ref, _transfer_ref, _burn_ref, _mutate_metadata_ref, _) =
-            create_fungible_asset(creator);
-        let metadata = mint_ref.metadata;
-
-        let blocked_acc_store = create_test_store(blocked_acc, metadata);
-        account::set_account_info(signer::address_of(blocked_acc), 10, 0, 3, true);
-
-        let fa = mint(&mint_ref, 100);
-        deposit(blocked_acc_store, fa);
-    }
-
-    #[test(creator = @0xcafe, blocked_acc = @0x123)]
-    #[expected_failure(abort_code = 0x1005C, location = Self)]
-    fun test_deposit_blocked_account_with_ref(
-        creator: &signer, blocked_acc: &signer
-    ) acquires FungibleStore, Supply {
-        let (mint_ref, transfer_ref, _burn_ref, _mutate_metadata_ref, _) =
-            create_fungible_asset(creator);
-        let metadata = mint_ref.metadata;
-
-        let blocked_acc_store = create_test_store(blocked_acc, metadata);
-        account::set_account_info(signer::address_of(blocked_acc), 10, 0, 3, true);
-
-        let fa = mint(&mint_ref, 100);
-        deposit_with_ref(&transfer_ref, blocked_acc_store, fa);
-    }
-}