Problem with coin metadata in aptos_framework::coin

[jny0444]

Discord user ID

No response

Describe your question in detail.

I am having issues with trying to run test cases for a simple aptos coin I made, I dont want to use fungible asset for now.
When I run aptos move test, I get this:

Running Move unit tests
[debug] "Restaked Token initialized successfully
"
[ FAIL    ] 0x89a3d491dc76466ed4900860d0cbf201ce5b3389ef59fa71f324d8cd4fdb32c2::token_test::test_restaked_token_flow

Test failures:

Failures in 0x89a3d491dc76466ed4900860d0cbf201ce5b3389ef59fa71f324d8cd4fdb32c2::token_test:

┌── test_restaked_token_flow ──────
│ error[E11001]: test failure
│     ┌─ /Users/{}/.move/https___github_com_aptos-labs_aptos-framework_git_mainnet/aptos-framework/sources/coin.move:320:9
│     │
│ 320 │         assert!(exists<CoinConversionMap>(@aptos_framework), error::not_found(ECOIN_CONVERSION_MAP_NOT_FOUND));
│     │         ^^^^^^ Test was not expected to error, but it aborted with code 393243 originating in the module 0000000000000000000000000000000000000000000000000000000000000001::coin rooted here
│     ·
│ 372 │     public(friend) fun ensure_paired_metadata<CoinType>(): Object<Metadata> acquires CoinConversionMap, CoinInfo {
│     │                        ---------------------- In this function in 0x1::coin
│ 
│ 
│ stack trace
│       coin::withdraw(/Users/{}/.move/https___github_com_aptos-labs_aptos-framework_git_mainnet/aptos-framework/sources/coin.move:1140)
│       coin::transfer(/Users/{}/.move/https___github_com_aptos-labs_aptos-framework_git_mainnet/aptos-framework/sources/coin.move:1119)
│       restaked_token::transfer(/Users/{}/Programming/Github/aptos-liquid-restaking/sources/restaked_token.move:94)
│       token_test::test_restaked_token_flow(/Users/{}/Programming/Github/aptos-liquid-restaking/tests/token.test.move:32)
│ 
└──────────────────

Test result: FAILED. Total tests: 1; passed: 0; failed: 1
{
  "Error": "Move unit tests failed"
}

The test code is :

module liq_restaking::token_test {
    #[test_only]
    use liq_restaking::staked_token;
    use std::signer;
    use aptos_framework::coin;
    use aptos_framework::account;
    use liq_restaking::restaked_token;
    use std::debug::print;
    use std::string::utf8;

    #[test(admin = @liq_restaking, user1 = @0x1, user2 = @0x2)]
    fun test_restaked_token_flow(
        admin: &signer, user1: &signer, user2: &signer
    ) {
        account::create_account_for_test(signer::address_of(user1));
        account::create_account_for_test(signer::address_of(user2));

        restaked_token::initialize(admin);

        print(&utf8(b"Restaked Token initialized successfully\n"));

        // coin::register<restaked_token::RSToken>(user1);
        // coin::register<restaked_token::RSToken>(user2);
        restaked_token::register<restaked_token::RSToken>(user1);
        restaked_token::register<restaked_token::RSToken>(user2);

        restaked_token::mint<restaked_token::RSToken>(
            admin, signer::address_of(user1), 100
        );
        assert!(restaked_token::balance_of(signer::address_of(user1)) == 100, 101);

        restaked_token::transfer(user1, signer::address_of(user2), 30);
        assert!(restaked_token::balance_of(signer::address_of(user1)) == 70, 102);
        assert!(restaked_token::balance_of(signer::address_of(user2)) == 30, 103);

        // restaked_token::burn(user1, 20);
        // assert!(restaked_token::balance_of(signer::address_of(user1)) == 50, 104);
    }
}

the contract is:

module liq_restaking::restaked_token {
    use aptos_framework::coin;
    use std::signer;
    use std::string::utf8;

    const E_NOT_ENOUGH_BALANCE: u64 = 1;
    const E_NOT_ADMIN: u64 = 2;
    const E_NOT_REGISTERED: u64 = 3;

    struct RSToken {}

    struct RSTokenCapabilities<phantom RSToken> has key {
        burn_cap: coin::BurnCapability<RSToken>,
        freeze_cap: coin::FreezeCapability<RSToken>,
        mint_cap: coin::MintCapability<RSToken>
    }

    public fun initialize(account: &signer) {
        // Chore: look into metadata

        let (burn_cap, freeze_cap, mint_cap) =
            coin::initialize<RSToken>(
                account,
                utf8(b"Restaked Token"),
                utf8(b"rsTKN"),
                8,
                false
            );

        assert!(signer::address_of(account) == @liq_restaking, E_NOT_ADMIN);
        assert!(
            !exists<RSTokenCapabilities<RSToken>>(signer::address_of(account)),
            E_NOT_ADMIN
        );

        move_to(
            account,
            RSTokenCapabilities {
                burn_cap: burn_cap,
                freeze_cap: freeze_cap,
                mint_cap: mint_cap
            }
        );
    }

    public entry fun register<RSToken>(account: &signer) {
        let account_address = signer::address_of(account);
        assert!(
            !coin::is_account_registered<RSToken>(account_address), E_NOT_REGISTERED
        );

        coin::register<RSToken>(account);
    }

    public fun mint<RSToken>(
        minter: &signer, recipient: address, amount: u64
    ) acquires RSTokenCapabilities {
        let minter = signer::address_of(minter);

        assert!(minter == @liq_restaking, E_NOT_ADMIN);
        assert!(
            exists<RSTokenCapabilities<RSToken>>(minter),
            E_NOT_ADMIN
        );

        let mint_capability = borrow_global<RSTokenCapabilities<RSToken>>(minter);
        let mint_cap = &mint_capability.mint_cap;

        let coins_minted = coin::mint<RSToken>(amount, mint_cap);

        coin::deposit<RSToken>(recipient, coins_minted);
    }

    public fun burn(burner: &signer, amount: u64) acquires RSTokenCapabilities {
        let burner_address = signer::address_of(burner);

        let balance = balance_of(burner_address);
        assert!(balance >= amount, E_NOT_ENOUGH_BALANCE);

        let coin = coin::withdraw<RSToken>(burner, amount);

        let burn_capability = borrow_global<RSTokenCapabilities<RSToken>>(burner_address);
        let burn_cap = &burn_capability.burn_cap;

        coin::burn<RSToken>(coin, burn_cap);
    }

    public fun transfer(user: &signer, receiver: address, amount: u64) {
        let user_address = signer::address_of(user);
        let balance = balance_of(user_address);

        assert!(balance >= amount, E_NOT_ENOUGH_BALANCE);

        coin::transfer<RSToken>(user, receiver, amount);
    }

    #[view]
    public fun balance_of(account: address): u64 {
        coin::balance<RSToken>(account)
    }
}

What error, if any, are you getting?

No response

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)

Aptos CLI

Describe your environment or tooling in detail

No response