coin - [mainnet]

public fun paired_metadata<CoinType>(): Option<Object<Metadata>> acquires CoinConversionMap {
    if (exists<CoinConversionMap>(@aptos_framework) && features::coin_to_fungible_asset_migration_feature_enabled(
    )) {
        let map = &borrow_global<CoinConversionMap>(@aptos_framework).coin_to_fungible_asset_map;
        let type = type_info::type_of<CoinType>();
        if (table::contains(map, type)) {
            return option::some(*table::borrow(map, type))
        }
    };
    option::none()
}

public entry fun create_coin_conversion_map(aptos_framework: &signer) {
    system_addresses::assert_aptos_framework(aptos_framework);
    if (!exists<CoinConversionMap>(@aptos_framework)) {
        move_to(aptos_framework, CoinConversionMap {
            coin_to_fungible_asset_map: table::new(),
        })
    };
}

public entry fun create_pairing<CoinType>(
    aptos_framework: &signer
) acquires CoinConversionMap, CoinInfo {
    system_addresses::assert_aptos_framework(aptos_framework);
    create_and_return_paired_metadata_if_not_exist<CoinType>(true);
}

inline fun is_apt<CoinType>(): bool {
    type_info::type_name<CoinType>() == string::utf8(b"0x1::aptos_coin::AptosCoin")
}

inline fun create_and_return_paired_metadata_if_not_exist<CoinType>(allow_apt_creation: bool): Object<Metadata> {
    assert!(
        features::coin_to_fungible_asset_migration_feature_enabled(),
        error::invalid_state(EMIGRATION_FRAMEWORK_NOT_ENABLED)
    );
    assert!(exists<CoinConversionMap>(@aptos_framework), error::not_found(ECOIN_CONVERSION_MAP_NOT_FOUND));
    let map = borrow_global_mut<CoinConversionMap>(@aptos_framework);
    let type = type_info::type_of<CoinType>();
    if (!table::contains(&map.coin_to_fungible_asset_map, type)) {
        let is_apt = is_apt<CoinType>();
        assert!(!is_apt || allow_apt_creation, error::invalid_state(EAPT_PAIRING_IS_NOT_ENABLED));
        let metadata_object_cref =
            if (is_apt) {
                object::create_sticky_object_at_address(@aptos_framework, @aptos_fungible_asset)
            } else {
                object::create_named_object(
                    &create_signer::create_signer(@aptos_fungible_asset),
                    *string::bytes(&type_info::type_name<CoinType>())
                )
            };
        primary_fungible_store::create_primary_store_enabled_fungible_asset(
            &metadata_object_cref,
            option::none(),
            name<CoinType>(),
            symbol<CoinType>(),
            decimals<CoinType>(),
            string::utf8(b""),
            string::utf8(b""),
        );

        let metadata_object_signer = &object::generate_signer(&metadata_object_cref);
        let type = type_info::type_of<CoinType>();
        move_to(metadata_object_signer, PairedCoinType { type });
        let metadata_obj = object::object_from_constructor_ref(&metadata_object_cref);

        table::add(&mut map.coin_to_fungible_asset_map, type, metadata_obj);
        event::emit(PairCreation {
            coin_type: type,
            fungible_asset_metadata_address: object_address(&metadata_obj)
        });

        // Generates all three refs
        let mint_ref = fungible_asset::generate_mint_ref(&metadata_object_cref);
        let transfer_ref = fungible_asset::generate_transfer_ref(&metadata_object_cref);
        let burn_ref = fungible_asset::generate_burn_ref(&metadata_object_cref);
        move_to(metadata_object_signer,
            PairedFungibleAssetRefs {
                mint_ref_opt: option::some(mint_ref),
                transfer_ref_opt: option::some(transfer_ref),
                burn_ref_opt: option::some(burn_ref),
            }
        );
    };
    *table::borrow(&map.coin_to_fungible_asset_map, type)
}

public(friend) fun ensure_paired_metadata<CoinType>(): Object<Metadata> acquires CoinConversionMap, CoinInfo {
    create_and_return_paired_metadata_if_not_exist<CoinType>(false)
}

public fun paired_coin(metadata: Object<Metadata>): Option<TypeInfo> acquires PairedCoinType {
    let metadata_addr = object::object_address(&metadata);
    if (exists<PairedCoinType>(metadata_addr)) {
        option::some(borrow_global<PairedCoinType>(metadata_addr).type)
    } else {
        option::none()
    }
}

public fun coin_to_fungible_asset<CoinType>(
    coin: Coin<CoinType>
): FungibleAsset acquires CoinConversionMap, CoinInfo {
    let metadata = ensure_paired_metadata<CoinType>();
    let amount = burn_internal(coin);
    fungible_asset::mint_internal(metadata, amount)
}

fun fungible_asset_to_coin<CoinType>(
    fungible_asset: FungibleAsset
): Coin<CoinType> acquires CoinInfo, PairedCoinType {
    let metadata_addr = object::object_address(&fungible_asset::metadata_from_asset(&fungible_asset));
    assert!(
        object::object_exists<PairedCoinType>(metadata_addr),
        error::not_found(EPAIRED_COIN)
    );
    let coin_type_info = borrow_global<PairedCoinType>(metadata_addr).type;
    assert!(coin_type_info == type_info::type_of<CoinType>(), error::invalid_argument(ECOIN_TYPE_MISMATCH));
    let amount = fungible_asset::burn_internal(fungible_asset);
    mint_internal<CoinType>(amount)
}

inline fun assert_paired_metadata_exists<CoinType>(): Object<Metadata> {
    let metadata_opt = paired_metadata<CoinType>();
    assert!(option::is_some(&metadata_opt), error::not_found(EPAIRED_FUNGIBLE_ASSET));
    option::destroy_some(metadata_opt)
}

public fun paired_mint_ref_exists<CoinType>(): bool acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    option::is_some(&borrow_global<PairedFungibleAssetRefs>(metadata_addr).mint_ref_opt)
}

public fun get_paired_mint_ref<CoinType>(
    _: &MintCapability<CoinType>
): (MintRef, MintRefReceipt) acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    let mint_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).mint_ref_opt;
    assert!(option::is_some(mint_ref_opt), error::not_found(EMINT_REF_NOT_FOUND));
    (option::extract(mint_ref_opt), MintRefReceipt { metadata })
}

public fun return_paired_mint_ref(mint_ref: MintRef, receipt: MintRefReceipt) acquires PairedFungibleAssetRefs {
    let MintRefReceipt { metadata } = receipt;
    assert!(
        fungible_asset::mint_ref_metadata(&mint_ref) == metadata,
        error::invalid_argument(EMINT_REF_RECEIPT_MISMATCH)
    );
    let metadata_addr = object_address(&metadata);
    let mint_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).mint_ref_opt;
    option::fill(mint_ref_opt, mint_ref);
}

public fun paired_transfer_ref_exists<CoinType>(): bool acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    option::is_some(&borrow_global<PairedFungibleAssetRefs>(metadata_addr).transfer_ref_opt)
}

public fun get_paired_transfer_ref<CoinType>(
    _: &FreezeCapability<CoinType>
): (TransferRef, TransferRefReceipt) acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    let transfer_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).transfer_ref_opt;
    assert!(option::is_some(transfer_ref_opt), error::not_found(ETRANSFER_REF_NOT_FOUND));
    (option::extract(transfer_ref_opt), TransferRefReceipt { metadata })
}

public fun return_paired_transfer_ref(
    transfer_ref: TransferRef,
    receipt: TransferRefReceipt
) acquires PairedFungibleAssetRefs {
    let TransferRefReceipt { metadata } = receipt;
    assert!(
        fungible_asset::transfer_ref_metadata(&transfer_ref) == metadata,
        error::invalid_argument(ETRANSFER_REF_RECEIPT_MISMATCH)
    );
    let metadata_addr = object_address(&metadata);
    let transfer_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).transfer_ref_opt;
    option::fill(transfer_ref_opt, transfer_ref);
}

public fun paired_burn_ref_exists<CoinType>(): bool acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    option::is_some(&borrow_global<PairedFungibleAssetRefs>(metadata_addr).burn_ref_opt)
}

public fun get_paired_burn_ref<CoinType>(
    _: &BurnCapability<CoinType>
): (BurnRef, BurnRefReceipt) acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    let burn_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).burn_ref_opt;
    assert!(option::is_some(burn_ref_opt), error::not_found(EBURN_REF_NOT_FOUND));
    (option::extract(burn_ref_opt), BurnRefReceipt { metadata })
}

public fun convert_and_take_paired_burn_ref<CoinType>(
    burn_cap: BurnCapability<CoinType>
): BurnRef acquires CoinConversionMap, PairedFungibleAssetRefs {
    destroy_burn_cap(burn_cap);
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    let burn_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).burn_ref_opt;
    assert!(option::is_some(burn_ref_opt), error::not_found(EBURN_REF_NOT_FOUND));
    option::extract(burn_ref_opt)
}

public fun return_paired_burn_ref(
    burn_ref: BurnRef,
    receipt: BurnRefReceipt
) acquires PairedFungibleAssetRefs {
    let BurnRefReceipt { metadata } = receipt;
    assert!(
        fungible_asset::burn_ref_metadata(&burn_ref) == metadata,
        error::invalid_argument(EBURN_REF_RECEIPT_MISMATCH)
    );
    let metadata_addr = object_address(&metadata);
    let burn_ref_opt = &mut borrow_global_mut<PairedFungibleAssetRefs>(metadata_addr).burn_ref_opt;
    option::fill(burn_ref_opt, burn_ref);
}

inline fun borrow_paired_burn_ref<CoinType>(
    _: &BurnCapability<CoinType>
): &BurnRef acquires CoinConversionMap, PairedFungibleAssetRefs {
    let metadata = assert_paired_metadata_exists<CoinType>();
    let metadata_addr = object_address(&metadata);
    assert!(exists<PairedFungibleAssetRefs>(metadata_addr), error::internal(EPAIRED_FUNGIBLE_ASSET_REFS_NOT_FOUND));
    let burn_ref_opt = &borrow_global<PairedFungibleAssetRefs>(metadata_addr).burn_ref_opt;
    assert!(option::is_some(burn_ref_opt), error::not_found(EBURN_REF_NOT_FOUND));
    option::borrow(burn_ref_opt)
}

public fun allow_supply_upgrades(_aptos_framework: &signer, _allowed: bool) {
    abort error::invalid_state(ECOIN_SUPPLY_UPGRADE_NOT_SUPPORTED)
}

inline fun calculate_amount_to_withdraw<CoinType>(
    account_addr: address,
    amount: u64
): (u64, u64) {
    let coin_balance = coin_balance<CoinType>(account_addr);
    if (coin_balance >= amount) {
        (amount, 0)
    } else {
        let metadata = paired_metadata<CoinType>();
        if (option::is_some(&metadata) && primary_fungible_store::primary_store_exists(
            account_addr,
            option::destroy_some(metadata)
        ))
            (coin_balance, amount - coin_balance)
        else
            abort error::invalid_argument(EINSUFFICIENT_BALANCE)
    }
}

fun maybe_convert_to_fungible_store<CoinType>(account: address) acquires CoinStore, CoinConversionMap, CoinInfo {
    if (!features::coin_to_fungible_asset_migration_feature_enabled()) {
        abort error::unavailable(ECOIN_TO_FUNGIBLE_ASSET_FEATURE_NOT_ENABLED)
    };
    assert!(is_coin_initialized<CoinType>(), error::invalid_argument(ECOIN_INFO_NOT_PUBLISHED));

    let metadata = ensure_paired_metadata<CoinType>();
    let store = primary_fungible_store::ensure_primary_store_exists(account, metadata);
    if (exists<CoinStore<CoinType>>(account)) {
        let CoinStore<CoinType> { coin, frozen, deposit_events, withdraw_events } = move_from<CoinStore<CoinType>>(
            account
        );
        event::emit(
            CoinStoreDeletion {
                coin_type: type_info::type_name<CoinType>(),
                event_handle_creation_address: guid::creator_address(
                    event::guid(&deposit_events)
                ),
                deleted_deposit_event_handle_creation_number: guid::creation_num(event::guid(&deposit_events)),
                deleted_withdraw_event_handle_creation_number: guid::creation_num(event::guid(&withdraw_events))
            }
        );
        if (coin.value == 0) {
            destroy_zero(coin);
        } else {
            fungible_asset::unchecked_deposit_with_no_events(object_address(&store), coin_to_fungible_asset(coin));
        };
        event::destroy_handle(deposit_events);
        event::destroy_handle(withdraw_events);
        // Note:
        // It is possible the primary fungible store may already exist before this function call.
        // In this case, if the account owns a frozen CoinStore and an unfrozen primary fungible store, this
        // function would convert and deposit the rest coin into the primary store and freeze it to make the
        // `frozen` semantic as consistent as possible.
        if (frozen != fungible_asset::is_frozen(store)) {
            fungible_asset::set_frozen_flag_internal(store, frozen);
        }
    };
}

inline fun assert_signer_has_permission<CoinType>(account: &signer) {
    if(permissioned_signer::is_permissioned_signer(account)) {
        fungible_asset::withdraw_permission_check_by_address(
            account,
            primary_fungible_store::primary_store_address(
                signer::address_of(account),
                ensure_paired_metadata<CoinType>()
            ),
            0
        );
    }
}

public entry fun migrate_to_fungible_store<CoinType>(
    account: &signer
) acquires CoinStore, CoinConversionMap, CoinInfo {
    let account_addr = signer::address_of(account);
    assert_signer_has_permission<CoinType>(account);
    maybe_convert_to_fungible_store<CoinType>(account_addr);
}

public entry fun migrate_coin_store_to_fungible_store<CoinType>(
    accounts: vector<address>
) acquires CoinStore, CoinConversionMap, CoinInfo {
    if (features::new_accounts_default_to_fa_store_enabled() || features::new_accounts_default_to_fa_apt_store_enabled()) {
        std::vector::for_each(accounts, |account| {
            maybe_convert_to_fungible_store<CoinType>(account);
        });
    }
}

fun coin_address<CoinType>(): address {
    let type_info = type_info::type_of<CoinType>();
    type_info::account_address(&type_info)
}

public fun balance<CoinType>(owner: address): u64 acquires CoinConversionMap, CoinStore {
    let paired_metadata = paired_metadata<CoinType>();
    coin_balance<CoinType>(owner) + if (option::is_some(&paired_metadata)) {
        primary_fungible_store::balance(
            owner,
            option::extract(&mut paired_metadata)
        )
    } else { 0 }
}

public fun is_balance_at_least<CoinType>(owner: address, amount: u64): bool acquires CoinConversionMap, CoinStore {
    let coin_balance = coin_balance<CoinType>(owner);
    if (coin_balance >= amount) {
        return true
    };

    let paired_metadata = paired_metadata<CoinType>();
    let left_amount = amount - coin_balance;
    if (option::is_some(&paired_metadata)) {
        primary_fungible_store::is_balance_at_least(
            owner,
            option::extract(&mut paired_metadata),
            left_amount
        )
    } else { false }
}

inline fun coin_balance<CoinType>(owner: address): u64 {
    if (exists<CoinStore<CoinType>>(owner)) {
        borrow_global<CoinStore<CoinType>>(owner).coin.value
    } else {
        0
    }
}

public fun is_coin_initialized<CoinType>(): bool {
    exists<CoinInfo<CoinType>>(coin_address<CoinType>())
}

public fun is_coin_store_frozen<CoinType>(
    account_addr: address
): bool acquires CoinStore, CoinConversionMap, CoinInfo {
    if (!is_account_registered<CoinType>(account_addr)) {
        return true
    };

    let coin_store = borrow_global<CoinStore<CoinType>>(account_addr);
    coin_store.frozen
}

public fun is_account_registered<CoinType>(account_addr: address): bool acquires CoinConversionMap, CoinInfo {
    assert!(is_coin_initialized<CoinType>(), error::invalid_argument(ECOIN_INFO_NOT_PUBLISHED));
    if (exists<CoinStore<CoinType>>(account_addr)) {
        true
    } else {
        let paired_metadata = ensure_paired_metadata<CoinType>();
        can_receive_paired_fungible_asset(account_addr, paired_metadata)
    }
}

public fun name<CoinType>(): string::String acquires CoinInfo {
    borrow_global<CoinInfo<CoinType>>(coin_address<CoinType>()).name
}

public fun symbol<CoinType>(): string::String acquires CoinInfo {
    borrow_global<CoinInfo<CoinType>>(coin_address<CoinType>()).symbol
}

public fun decimals<CoinType>(): u8 acquires CoinInfo {
    borrow_global<CoinInfo<CoinType>>(coin_address<CoinType>()).decimals
}

public fun supply<CoinType>(): Option<u128> acquires CoinInfo, CoinConversionMap {
    let coin_supply = coin_supply<CoinType>();
    let metadata = paired_metadata<CoinType>();
    if (option::is_some(&metadata)) {
        let fungible_asset_supply = fungible_asset::supply(option::extract(&mut metadata));
        if (option::is_some(&coin_supply)) {
            let supply = option::borrow_mut(&mut coin_supply);
            *supply = *supply + option::destroy_some(fungible_asset_supply);
        };
    };
    coin_supply
}

public fun coin_supply<CoinType>(): Option<u128> acquires CoinInfo {
    let maybe_supply = &borrow_global<CoinInfo<CoinType>>(coin_address<CoinType>()).supply;
    if (option::is_some(maybe_supply)) {
        // We do track supply, in this case read from optional aggregator.
        let supply = option::borrow(maybe_supply);
        let value = optional_aggregator::read(supply);
        option::some(value)
    } else {
        option::none()
    }
}

public fun burn<CoinType>(coin: Coin<CoinType>, _cap: &BurnCapability<CoinType>) acquires CoinInfo {
    burn_internal(coin);
}

public fun burn_from<CoinType>(
    account_addr: address,
    amount: u64,
    burn_cap: &BurnCapability<CoinType>,
) acquires CoinInfo, CoinStore, CoinConversionMap, PairedFungibleAssetRefs {
    // Skip burning if amount is zero. This shouldn't error out as it's called as part of transaction fee burning.
    if (amount == 0) {
        return
    };

    let (coin_amount_to_burn, fa_amount_to_burn) = calculate_amount_to_withdraw<CoinType>(
        account_addr,
        amount
    );
    if (coin_amount_to_burn > 0) {
        let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
        let coin_to_burn = extract(&mut coin_store.coin, coin_amount_to_burn);
        burn(coin_to_burn, burn_cap);
    };
    if (fa_amount_to_burn > 0) {
        fungible_asset::burn_from(
            borrow_paired_burn_ref(burn_cap),
            primary_fungible_store::primary_store(account_addr, option::destroy_some(paired_metadata<CoinType>())),
            fa_amount_to_burn
        );
    };
}

public(friend) fun burn_from_for_gas<CoinType>(
    account_addr: address,
    amount: u64,
    burn_cap: &BurnCapability<CoinType>,
) acquires CoinInfo, CoinStore, CoinConversionMap, PairedFungibleAssetRefs {
    // Skip burning if amount is zero. This shouldn't error out as it's called as part of transaction fee burning.
    if (amount == 0) {
        return
    };

    let (coin_amount_to_burn, fa_amount_to_burn) = calculate_amount_to_withdraw<CoinType>(
        account_addr,
        amount
    );
    if (coin_amount_to_burn > 0) {
        let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
        let coin_to_burn = extract(&mut coin_store.coin, coin_amount_to_burn);
        burn(coin_to_burn, burn_cap);
    };
    if (fa_amount_to_burn > 0) {
        fungible_asset::address_burn_from_for_gas(
            borrow_paired_burn_ref(burn_cap),
            primary_fungible_store::primary_store_address(account_addr, option::destroy_some(paired_metadata<CoinType>())),
            fa_amount_to_burn
        );
    };
}

public fun deposit<CoinType>(
    account_addr: address,
    coin: Coin<CoinType>
) acquires CoinStore, CoinConversionMap, CoinInfo {
    if (exists<CoinStore<CoinType>>(account_addr)) {
        let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
        assert!(
            !coin_store.frozen,
            error::permission_denied(EFROZEN),
        );
            event::emit_event<DepositEvent>(
                &mut coin_store.deposit_events,
                DepositEvent { amount: coin.value },
            );
        merge(&mut coin_store.coin, coin);
    } else {
        let metadata = ensure_paired_metadata<CoinType>();
        if (can_receive_paired_fungible_asset( account_addr, metadata)) {
            primary_fungible_store::deposit(account_addr, coin_to_fungible_asset(coin));
        } else {
            abort error::not_found(ECOIN_STORE_NOT_PUBLISHED)
        };
    }
}

public fun deposit_with_signer<CoinType>(
    account: &signer,
    coin: Coin<CoinType>
) acquires CoinStore, CoinConversionMap, CoinInfo {
    let metadata = ensure_paired_metadata<CoinType>();
    let account_address = signer::address_of(account);
    fungible_asset::refill_permission(
        account,
        coin.value,
        primary_fungible_store::primary_store_address_inlined(
            account_address,
            metadata,
        )
    );
    deposit(account_address, coin);
}

inline fun can_receive_paired_fungible_asset(
    account_address: address,
    metadata: Object<Metadata>
): bool {
    features::new_accounts_default_to_fa_store_enabled() || (features::new_accounts_default_to_fa_apt_store_enabled() && object::object_address(&metadata) == @0xa) || {
        let primary_store_address = primary_fungible_store::primary_store_address<Metadata>(
            account_address,
            metadata
        );
        fungible_asset::store_exists(primary_store_address)
    }
}

public(friend) fun deposit_for_gas_fee<CoinType>(
    account_addr: address,
    coin: Coin<CoinType>
) acquires CoinStore, CoinConversionMap, CoinInfo {
    if (exists<CoinStore<CoinType>>(account_addr)) {
        let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
        merge(&mut coin_store.coin, coin);
    } else {
        let metadata = ensure_paired_metadata<CoinType>();
        if (can_receive_paired_fungible_asset(
            account_addr,
            metadata
        )) {
            let fa = coin_to_fungible_asset(coin);
            let metadata = fungible_asset::asset_metadata(&fa);
            let store = primary_fungible_store::ensure_primary_store_exists(account_addr, metadata);
            fungible_asset::unchecked_deposit_with_no_events(object::object_address(&store), fa);
        } else {
            abort error::not_found(ECOIN_STORE_NOT_PUBLISHED)
        }
    }
}

public fun destroy_zero<CoinType>(zero_coin: Coin<CoinType>) {
    spec {
        update supply<CoinType> = supply<CoinType> - zero_coin.value;
    };
    let Coin { value } = zero_coin;
    assert!(value == 0, error::invalid_argument(EDESTRUCTION_OF_NONZERO_TOKEN))
}

public fun extract<CoinType>(coin: &mut Coin<CoinType>, amount: u64): Coin<CoinType> {
    assert!(coin.value >= amount, error::invalid_argument(EINSUFFICIENT_BALANCE));
    spec {
        update supply<CoinType> = supply<CoinType> - amount;
    };
    coin.value = coin.value - amount;
    spec {
        update supply<CoinType> = supply<CoinType> + amount;
    };
    Coin { value: amount }
}

public fun extract_all<CoinType>(coin: &mut Coin<CoinType>): Coin<CoinType> {
    let total_value = coin.value;
    spec {
        update supply<CoinType> = supply<CoinType> - coin.value;
    };
    coin.value = 0;
    spec {
        update supply<CoinType> = supply<CoinType> + total_value;
    };
    Coin { value: total_value }
}

public entry fun freeze_coin_store<CoinType>(
    account_addr: address,
    _freeze_cap: &FreezeCapability<CoinType>,
) acquires CoinStore {
    let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
    coin_store.frozen = true;
}

public entry fun unfreeze_coin_store<CoinType>(
    account_addr: address,
    _freeze_cap: &FreezeCapability<CoinType>,
) acquires CoinStore {
    let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
    coin_store.frozen = false;
}

public entry fun upgrade_supply<CoinType>(_account: &signer) {
    abort error::invalid_state(ECOIN_SUPPLY_UPGRADE_NOT_SUPPORTED)
}

public fun initialize<CoinType>(
    account: &signer,
    name: string::String,
    symbol: string::String,
    decimals: u8,
    monitor_supply: bool,
): (BurnCapability<CoinType>, FreezeCapability<CoinType>, MintCapability<CoinType>) acquires CoinInfo, CoinConversionMap {
    initialize_internal(account, name, symbol, decimals, monitor_supply, false)
}

public(friend) fun initialize_with_parallelizable_supply<CoinType>(
    account: &signer,
    name: string::String,
    symbol: string::String,
    decimals: u8,
    monitor_supply: bool,
): (BurnCapability<CoinType>, FreezeCapability<CoinType>, MintCapability<CoinType>) acquires CoinInfo, CoinConversionMap {
    system_addresses::assert_aptos_framework(account);
    initialize_internal(account, name, symbol, decimals, monitor_supply, true)
}

fun initialize_internal<CoinType>(
    account: &signer,
    name: string::String,
    symbol: string::String,
    decimals: u8,
    monitor_supply: bool,
    parallelizable: bool,
): (BurnCapability<CoinType>, FreezeCapability<CoinType>, MintCapability<CoinType>) acquires CoinInfo, CoinConversionMap {
    let account_addr = signer::address_of(account);
    assert_signer_has_permission<CoinType>(account);

    assert!(
        coin_address<CoinType>() == account_addr,
        error::invalid_argument(ECOIN_INFO_ADDRESS_MISMATCH),
    );

    assert!(
        !exists<CoinInfo<CoinType>>(account_addr),
        error::already_exists(ECOIN_INFO_ALREADY_PUBLISHED),
    );

    assert!(string::length(&name) <= MAX_COIN_NAME_LENGTH, error::invalid_argument(ECOIN_NAME_TOO_LONG));
    assert!(string::length(&symbol) <= MAX_COIN_SYMBOL_LENGTH, error::invalid_argument(ECOIN_SYMBOL_TOO_LONG));

    let coin_info = CoinInfo<CoinType> {
        name,
        symbol,
        decimals,
        supply: if (monitor_supply) {
            option::some(
                optional_aggregator::new(parallelizable)
            )
        } else { option::none() },
    };
    move_to(account, coin_info);

    (BurnCapability<CoinType> {}, FreezeCapability<CoinType> {}, MintCapability<CoinType> {})
}

public fun merge<CoinType>(dst_coin: &mut Coin<CoinType>, source_coin: Coin<CoinType>) {
    spec {
        assume dst_coin.value + source_coin.value <= MAX_U64;
    };
    spec {
        update supply<CoinType> = supply<CoinType> - source_coin.value;
    };
    let Coin { value } = source_coin;
    spec {
        update supply<CoinType> = supply<CoinType> + value;
    };
    dst_coin.value = dst_coin.value + value;
}

public fun mint<CoinType>(
    amount: u64,
    _cap: &MintCapability<CoinType>,
): Coin<CoinType> acquires CoinInfo {
    mint_internal<CoinType>(amount)
}

public fun register<CoinType>(account: &signer) acquires CoinInfo, CoinConversionMap {
    let account_addr = signer::address_of(account);
    assert_signer_has_permission<CoinType>(account);
    // Short-circuit and do nothing if account is already registered for CoinType.
    if (is_account_registered<CoinType>(account_addr)) {
        return
    };

    account::register_coin<CoinType>(account_addr);
    let coin_store = CoinStore<CoinType> {
        coin: Coin { value: 0 },
        frozen: false,
        deposit_events: account::new_event_handle<DepositEvent>(account),
        withdraw_events: account::new_event_handle<WithdrawEvent>(account),
    };
    move_to(account, coin_store);
}

public entry fun transfer<CoinType>(
    from: &signer,
    to: address,
    amount: u64,
) acquires CoinStore, CoinConversionMap, CoinInfo, PairedCoinType {
    let coin = withdraw<CoinType>(from, amount);
    deposit(to, coin);
}

public fun value<CoinType>(coin: &Coin<CoinType>): u64 {
    coin.value
}

public fun withdraw<CoinType>(
    account: &signer,
    amount: u64,
): Coin<CoinType> acquires CoinStore, CoinConversionMap, CoinInfo, PairedCoinType {
    let account_addr = signer::address_of(account);

    let (coin_amount_to_withdraw, fa_amount_to_withdraw) = calculate_amount_to_withdraw<CoinType>(
        account_addr,
        amount
    );
    let withdrawn_coin = if (coin_amount_to_withdraw > 0) {
        let metadata = ensure_paired_metadata<CoinType>();
        if(permissioned_signer::is_permissioned_signer(account)) {
            // Perform the check only if the account is a permissioned signer to save the cost of
            // computing the primary store location.
            fungible_asset::withdraw_permission_check_by_address(
                account,
                primary_fungible_store::primary_store_address(account_addr, metadata),
                coin_amount_to_withdraw
            );
        };

        let coin_store = borrow_global_mut<CoinStore<CoinType>>(account_addr);
        assert!(
            !coin_store.frozen,
            error::permission_denied(EFROZEN),
        );
        event::emit_event<WithdrawEvent>(
            &mut coin_store.withdraw_events,
            WithdrawEvent { amount: coin_amount_to_withdraw },
        );
        extract(&mut coin_store.coin, coin_amount_to_withdraw)
    } else {
        zero()
    };
    if (fa_amount_to_withdraw > 0) {
        let fa = primary_fungible_store::withdraw(
            account,
            option::destroy_some(paired_metadata<CoinType>()),
            fa_amount_to_withdraw
        );
        merge(&mut withdrawn_coin, fungible_asset_to_coin(fa));
    };
    withdrawn_coin
}