Sending ERC-20 fungible token from Metamask fails

[re-gius]

I built an ERC-20 fungible token. Token transfers work perfectly in Remix and also show in Metamask browser extension, but token transfer directly from metamask (send button) does not work.

if I push the send button, the transaction eventually fails (498 CMPN fail). The succesful send (1500 CMPN) was from Remix by calling the transfer function.

To reproduce it, you can deploy the following smart contract on Remix. The owner/deployer can mint new tokens with mintTokens(address destination_account, uint tokens_amount). Then you can try sending the minted tokens to a different account with Metamask browser extension.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract CharityToken is ERC20 {
    address public caller;
    address public authority;
    mapping(address => bool) public frozen;

    event Frozen(address account);
    event Unfrozen(address account);

    error Unauthorized();

    modifier onlyAuthorizedCaller {
        if (msg.sender != caller) {
            revert Unauthorized();
        }
        _;
    }

    modifier onlyAuthority {
        if (msg.sender != authority) {
            revert Unauthorized();
        }
        _;
    }

    constructor(address _authority) ERC20("Compassion", "CMPN") {
        caller = msg.sender;
        authority = _authority;
    }

    function mintTokens(address account, uint tokens) external onlyAuthorizedCaller {
        _mint(account, tokens);
    }

    function burnShopTokens(address shop) external onlyAuthorizedCaller {
        uint balance = balanceOf(shop);
        _burn(shop, balance);
    }

    function changeCaller(address new_caller) external onlyAuthority {
        caller = new_caller;
    }

    function freeze(address account) external onlyAuthority {
        frozen[account] = true;
        emit Frozen(account);   
    }

    function unfreeze(address account) external onlyAuthority {
        frozen[account] = false;
        emit Unfrozen(account);   
    }

   function is_frozen(address account) public view returns (bool) {
        return frozen[account];
    }

    function transfer(address to, uint256 value) override public returns (bool) {
        address owner = _msgSender();
        if (is_frozen(owner)) {
            revert Unauthorized();
        }
        _transfer(owner, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) override public returns (bool) {
        address spender = _msgSender();
        if (is_frozen(spender) || is_frozen(from)) {
            revert Unauthorized();
        }
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    function decimals() override public pure returns (uint8) {
        return 0;
    }
}

[re-gius]

@pgherveou here is the issue from the Discord chat.

[pgherveou]

This Metamask PR should fix the issue MetaMask/metamask-extension#30337

[pgherveou]

this should be fixed with the new gas model

[pgherveou]

still failing
from the westend logs

2025-10-20 13:55:35.293	
2025-10-20 11:55:35.258 DEBUG tokio-runtime-worker eth-rpc: submit call failed: SubxtError(Rpc(ClientError(User(UserError { code: 1010, message: "Invalid Transaction", data: Some(RawValue("Inability to pay some fees (e.g. account balance too low)")) }))))    

[pgherveou]

Turns out that for token transfer from metamask UI, MM do a eth_estimateGas call with an initial gas_limit of 100_000 to which it apply a 95% ratio,

so direct token transfers from the metamask UI fail because the dry_run fail because the arbirtrary gas picked by the wallet is way too low for our chain

[pgherveou]

@athei we need to scale our gas so that it's more in the bounds of ethereum.
to make these kind of workflow work

[pgherveou]

that's the request being done

{
    "id": "0259cb69-6ff5-4a79-a763-0ab7a59358c8",
    "jsonrpc": "2.0",
    "method": "eth_estimateGas",
    "params": [
        {
            "data": "0xa9059cbb000000000000000000000000340076a86fc852285a4b7308fa2316657861697e00000000000000000000000000000000000000000000000000000000000000c8",
            "from": "0xf24ff3a9cf04c71dbc94d0b566f7a27b94566cac",
            "gas": "0x17318",
            "gasPrice": "0xf4240",
            "to": "0xc01Ee7f10EA4aF4673cFff62710E1D7792aBa8f3",
            "value": "0x0"
        }
    ]
}

that's a transfer of an ERC20 token at 0xc01Ee7f10EA4aF4673cFff62710E1D7792aBa8f3

the gas is cast --to-dec 0x17318 = 95000

> cast 4byte-decode 0xa9059cbb000000000000000000000000340076a86fc852285a4b7308fa2316657861697e00000000000000000000000000000000000000000000000000000000000000c8

1) "transfer(address,uint256)"
0x340076a86fc852285a4b7308fA2316657861697e
200

[TorstenStueber]

This is fixed by paritytech/polkadot-sdk#10393

Setting GasScale in the dev node to 500_000 changed the gas requirements for the CharityToken contract as follows:

• transfer to an account with existing balance: 42473
  • this is 37303 with the built in node in Remix
• transfer to an account with zero balance: 47753
  • this is 54403 with the built in node in Remix

I could confirm that with these changes Metamask is indeed able to transfer tokens.