TYPE_MISMATCH" on Mainnet publish

[oscarthedev15]

Discord user ID

plnkerxd

Describe your question in detail.

getting this error on mainnet publish, Testnet and devnet worked fine:
"Error": "Simulation failed with status: TYPE_MISMATCH"

here is move.toml:

`
[package]
name = "xxx_token"
version = "1.0.0"
authors = []

[addresses]
my_management_addr='xxxx'

[dev-addresses]

[dependencies]
AptosFramework = { git = "https://github.com/aptos-labs/aptos-core.git",
subdir = "aptos-move/framework/aptos-framework",
rev = "mainnet" }

[dev-dependencies]
`

here is the module:
`
module my_management_addr::xxx_token {
use aptos_framework::fungible_asset::{Self, MintRef, TransferRef, BurnRef, Metadata, FungibleAsset};
use aptos_framework::object::{Self, Object};
use aptos_framework::primary_fungible_store;
use aptos_framework::function_info;
use aptos_framework::dispatchable_fungible_asset;
use std::error;
use std::signer;
use std::string::{Self, utf8};
use std::option;

/// Only fungible asset metadata owner can make changes.
const ENOT_OWNER: u64 = 1;
/// The FA coin is paused.
const EPAUSED: u64 = 2;

const ASSET_SYMBOL: vector<u8> = b"NYC";

#[resource_group_member(group = aptos_framework::object::ObjectGroup)]
/// Hold refs to control the minting, transfer and burning of fungible assets.
struct ManagedFungibleAsset has key {
    mint_ref: MintRef,
    transfer_ref: TransferRef,
    burn_ref: BurnRef,
}

#[resource_group_member(group = aptos_framework::object::ObjectGroup)]
/// Global state to pause the FA coin.
/// OPTIONAL
struct State has key {
    paused: bool,
}

/// Initialize metadata object and store the refs.
// :!:>initialize
fun init_module(admin: &signer) {
    let constructor_ref = &object::create_named_object(admin, ASSET_SYMBOL);
    primary_fungible_store::create_primary_store_enabled_fungible_asset(
        constructor_ref,
        option::none(),
        utf8(b"NYC Coin"), /* name */
        utf8(ASSET_SYMBOL), /* symbol */
        8, /* decimals */
        utf8(b"https://aptos-metadata.s3.us-east-2.amazonaws.com/xxxxx"), /* icon */
        utf8(b"http://xxxxx"), /* project */
    );

    // Create mint/burn/transfer refs to allow creator to manage the fungible asset.
    let mint_ref = fungible_asset::generate_mint_ref(constructor_ref);
    let burn_ref = fungible_asset::generate_burn_ref(constructor_ref);
    let transfer_ref = fungible_asset::generate_transfer_ref(constructor_ref);
    let metadata_object_signer = object::generate_signer(constructor_ref);
    move_to(
        &metadata_object_signer,
        ManagedFungibleAsset { mint_ref, transfer_ref, burn_ref }
    ); // <:!:initialize

    // Create a global state to pause the FA coin and move to Metadata object.
    move_to(
        &metadata_object_signer,
        State { paused: false, }
    );

    // Override the deposit and withdraw functions which mean overriding transfer.
    // This ensures all transfer will call withdraw and deposit functions in this module
    // and perform the necessary checks.
    // This is OPTIONAL. It is an advanced feature and we don't NEED a global state to pause the FA coin.
    let deposit = function_info::new_function_info(
        admin,
        string::utf8(b"xxx_token"),
        string::utf8(b"deposit"),
    );
    let withdraw = function_info::new_function_info(
        admin,
        string::utf8(b"xxx_token"),
        string::utf8(b"withdraw"),
    );
    dispatchable_fungible_asset::register_dispatch_functions(
        constructor_ref,
        option::some(withdraw),
        option::some(deposit),
        option::none(),
    );
}

#[view]
/// Return the address of the managed fungible asset that's created when this module is deployed.
public fun get_metadata(): Object<Metadata> {
    let asset_address = object::create_object_address(&@my_management_addr, ASSET_SYMBOL);
    object::address_to_object<Metadata>(asset_address)
}

/// Deposit function override to ensure that the account is not denylisted and the FA coin is not paused.
/// OPTIONAL
public fun deposit<T: key>(
    store: Object<T>,
    fa: FungibleAsset,
    transfer_ref: &TransferRef,
) acquires State {
    assert_not_paused();
    fungible_asset::deposit_with_ref(transfer_ref, store, fa);
}

/// Withdraw function override to ensure that the account is not denylisted and the FA coin is not paused.
/// OPTIONAL
public fun withdraw<T: key>(
    store: Object<T>,
    amount: u64,
    transfer_ref: &TransferRef,
): FungibleAsset acquires State {
    assert_not_paused();
    fungible_asset::withdraw_with_ref(transfer_ref, store, amount)
}

// :!:>mint
/// Mint as the owner of metadata object.
public entry fun mint(admin: &signer, to: address, amount: u64) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let managed_fungible_asset = authorized_borrow_refs(admin, asset);
    let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
    let fa = fungible_asset::mint(&managed_fungible_asset.mint_ref, amount);
    fungible_asset::deposit_with_ref(&managed_fungible_asset.transfer_ref, to_wallet, fa);
}// <:!:mint

/// Transfer as the owner of metadata object ignoring `frozen` field.
public entry fun transfer(admin: &signer, from: address, to: address, amount: u64) acquires ManagedFungibleAsset, State {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let from_wallet = primary_fungible_store::primary_store(from, asset);
    let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
    let fa = withdraw(from_wallet, amount, transfer_ref);
    deposit(to_wallet, fa, transfer_ref);
}

/// Burn fungible assets as the owner of metadata object.
public entry fun burn(admin: &signer, from: address, amount: u64) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let burn_ref = &authorized_borrow_refs(admin, asset).burn_ref;
    let from_wallet = primary_fungible_store::primary_store(from, asset);
    fungible_asset::burn_from(burn_ref, from_wallet, amount);
}

/// Freeze an account so it cannot transfer or receive fungible assets.
public entry fun freeze_account(admin: &signer, account: address) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let wallet = primary_fungible_store::ensure_primary_store_exists(account, asset);
    fungible_asset::set_frozen_flag(transfer_ref, wallet, true);
}

/// Unfreeze an account so it can transfer or receive fungible assets.
public entry fun unfreeze_account(admin: &signer, account: address) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let wallet = primary_fungible_store::ensure_primary_store_exists(account, asset);
    fungible_asset::set_frozen_flag(transfer_ref, wallet, false);
}

/// Pause or unpause the transfer of FA coin. This checks that the caller is the pauser.
public entry fun set_pause(pauser: &signer, paused: bool) acquires State {
    let asset = get_metadata();
    assert!(object::is_owner(asset, signer::address_of(pauser)), error::permission_denied(ENOT_OWNER));
    let state = borrow_global_mut<State>(object::create_object_address(&@my_management_addr, ASSET_SYMBOL));
    if (state.paused == paused) { return };
    state.paused = paused;
}

/// Assert that the FA coin is not paused.
/// OPTIONAL
fun assert_not_paused() acquires State {
    let state = borrow_global<State>(object::create_object_address(&@my_management_addr, ASSET_SYMBOL));
    assert!(!state.paused, EPAUSED);
}

/// Borrow the immutable reference of the refs of `metadata`.
/// This validates that the signer is the metadata object's owner.
inline fun authorized_borrow_refs(
    owner: &signer,
    asset: Object<Metadata>,
): &ManagedFungibleAsset acquires ManagedFungibleAsset {
    assert!(object::is_owner(asset, signer::address_of(owner)), error::permission_denied(ENOT_OWNER));
    borrow_global<ManagedFungibleAsset>(object::object_address(&asset))
}

#[test(creator = @my_management_addr)]
fun test_basic_flow(
    creator: &signer,
) acquires ManagedFungibleAsset, State {
    init_module(creator);
    let creator_address = signer::address_of(creator);
    let aaron_address = @0xface;

    mint(creator, creator_address, 100);
    let asset = get_metadata();
    assert!(primary_fungible_store::balance(creator_address, asset) == 100, 4);
    freeze_account(creator, creator_address);
    assert!(primary_fungible_store::is_frozen(creator_address, asset), 5);
    transfer(creator, creator_address, aaron_address, 10);
    assert!(primary_fungible_store::balance(aaron_address, asset) == 10, 6);

    unfreeze_account(creator, creator_address);
    assert!(!primary_fungible_store::is_frozen(creator_address, asset), 7);
    burn(creator, creator_address, 90);
}

#[test(creator = @my_management_addr, aaron = @0xface)]
#[expected_failure(abort_code = 0x50001, location = Self)]
fun test_permission_denied(
    creator: &signer,
    aaron: &signer
) acquires ManagedFungibleAsset {
    init_module(creator);
    let creator_address = signer::address_of(creator);
    mint(aaron, creator_address, 100);
}

#[test(creator = @my_management_addr)]
#[expected_failure(abort_code = 2, location = Self)]
fun test_paused(
    creator: &signer,
) acquires ManagedFungibleAsset, State {
    init_module(creator);
    let creator_address = signer::address_of(creator);
    mint(creator, creator_address, 100);
    set_pause(creator, true);
    transfer(creator, creator_address, @0xface, 10);
}

}
`

What error, if any, are you getting?

% aptos move publish
Compiling, may take a little while to download git dependencies...
FETCHING GIT DEPENDENCY https://github.com/aptos-labs/aptos-core.git
INCLUDING DEPENDENCY AptosFramework
INCLUDING DEPENDENCY AptosStdlib
INCLUDING DEPENDENCY MoveStdlib
BUILDING nameless_token
package size 5608 bytes
{
"Error": "Simulation failed with status: TYPE_MISMATCH"
}

What have you tried or looked at? Or how can we reproduce the error?

No response

Which operating system are you using?

macOS

Which SDK or tool are you using? (if any)

N/A

Describe your environment or tooling in detail

Using aptos CLI

[0x-j]

I can reproduce this one my end. Here's the simplest code to reproduce. The issue happens at the defining Metadata as return type of objectonpublic fun get_metadata(): Object {}, if i change MetadatatoObjectCoreorSupply, I have no issue deploying it. When i change and go to the deployment object on mainnet, i can see Metadata` do exist in the resource. Maybe there's something wrong with simulating publishing package in mainnet.

module my_management_addr::test_app {
    use aptos_framework::fungible_asset::{Self, MintRef, TransferRef, BurnRef, Metadata};
    use aptos_framework::object::{Self, Object};
    use aptos_framework::primary_fungible_store;

    use std::string;
    use std::option;

    /// Only fungible asset metadata owner can make changes.
    const ENOT_OWNER: u64 = 1;
    /// The FA coin is paused.
    const EPAUSED: u64 = 2;

    const ASSET_SYMBOL: vector<u8> = b"NYC";

    /// Hold refs to control the minting, transfer and burning of fungible assets.
    struct ManagedFungibleAsset has key {
        mint_ref: MintRef,
        transfer_ref: TransferRef,
        burn_ref: BurnRef,
    }

    /// Initialize metadata object and store the refs.
    fun init_module(admin: &signer) {
        let constructor_ref = &object::create_named_object(admin, ASSET_SYMBOL);
        primary_fungible_store::create_primary_store_enabled_fungible_asset(
            constructor_ref,
            option::none(),
            string::utf8(b"NYC Coin"), /* name */
            string::utf8(ASSET_SYMBOL), /* symbol */
            8, /* decimals */
            string::utf8(b"https://aptos-metadata.s3.us-east-2.amazonaws.com/xxxxx"), /* icon */
            string::utf8(b"http://xxxxx"), /* project */
        );

        // Create mint/burn/transfer refs to allow creator to manage the fungible asset.
        let mint_ref = fungible_asset::generate_mint_ref(constructor_ref);
        let burn_ref = fungible_asset::generate_burn_ref(constructor_ref);
        let transfer_ref = fungible_asset::generate_transfer_ref(constructor_ref);
        let metadata_object_signer = object::generate_signer(constructor_ref);
        move_to(
            &metadata_object_signer,
            ManagedFungibleAsset { mint_ref, transfer_ref, burn_ref }
        );
    }

    #[view]
    /// Return the address of the managed fungible asset that's created when this module is deployed.
    // Change return type from Metadata to ObjectCore can make publish work.
    public fun get_metadata(): Object<Metadata> {
        let asset_address = object::create_object_address(&@my_management_addr, ASSET_SYMBOL);
        object::address_to_object(asset_address)
    }
}

[oscarthedev15]

When i make this switch there are compiling issues on my end. Is this a valid substitution in terms of fungible asset functionality ?

[cryptomerias]

Odd, works on my end

[oscarthedev15]

if it helps, this code is forked from here:
https://github.com/aptos-labs/aptos-core/blob/main/aptos-move/move-examples/fungible_asset/fa_coin/sources/FACoin.move

[brmataptos]

There have been some recent changes to dynamic dispatch code in the framework. Is it possible you are building against the newer version of the AptosFramework, but trying to run on MainNet (which has a slightly older version deployed)?

[oscarthedev15]

@brmataptos any updates here?

[brmataptos]

The framework upgrade to mainnet is currently a governance proposal, to close in 5 days if passed (7/29). https://governance.aptosfoundation.org/proposal/94

[oscarthedev15]

Thanks, are there any other Fungible asset modules we could fork in the meantime?

[brmataptos]

@0xaptosj might know. I'm new to this area.

[0x-j]

@oscarthedev15, unfortunately, no, on aptos all fungible assets are managed by the 0x1::fungible_asset module. so we have to wait for the framework upgrade.