# Mint From Existing Contract

I have the following contract that is already deployed (pasted below). I can see where the `constructor()` method is doing an `emit Transfer` from the 0x0 (zero) address to the deployer address in order to mint the initial supply, but how would I use `emit Transfer` in another function to distribute tokens via mint OR how would I use the `transferFrom()` to mint new tokens with the same contract to the deployer address?

Couldn't I just do `transferFrom(0x0, msg.sender, SUPPLY_AMOUNT)`? Trying this, but keep getting an error.

I'm familiar with Remix, so if there's a way to do it there, I can probably get it.

Here's the contract code:

``````pragma solidity ^0.8.18;

contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}

library SafeMath {

function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}

function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}

function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}

contract BasicToken is ERC20Basic {
using SafeMath for uint256;

mapping(address => uint256) balances;

uint256 totalSupply_;

function totalSupply() public view returns (uint256) {
}

function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);

balances[msg.sender] = balances[msg.sender].sub(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}

function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}

}

contract ERC20 is ERC20Basic {
public view returns (uint256);

function transferFrom(address from, address to, uint256 value)
public returns (bool);

function approve(address spender, uint256 value) public returns (bool);
event Approval(
uint256 value
);
}

contract StandardToken is ERC20, BasicToken {

mapping (address => mapping (address => uint256)) internal allowed;

function transferFrom(
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);

balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}

function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}

function allowance(
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}

function increaseApproval(
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}

function decreaseApproval(
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}

}

contract MYTOKEN is StandardToken {

string public constant name = "MYTOKEN"; // solium-disable-line uppercase
string public constant symbol = "MYTOKEN"; // solium-disable-line uppercase
uint8 public constant decimals = 18; // solium-disable-line uppercase

uint256 public constant INITIAL_SUPPLY = 100000000 * (10 ** uint256(decimals));

constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}

}
``````

The line:

``````emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
``````

is emitting and event `Transfer`, its content does not have any effect on the blockchain. It only uses as a notification mechanism to off-chain code (for example, a webapp listening to this to show user about the event).

The only 2 ways you can mint token are:

1. Via the `_mint` function if that can be accessed by a public function and the token implements it (mintable) ERC20 Openzeppelin
2. Change the `balances[addr]` and `totalSupply_` directly (which is what happens in the above constructor).

Because you cannot call the `constructor` of deployed contract and there are no ways to achieve any of the above methods, the answer to your question is it's not possible. You must implement a new token or deploy a new instance of the contract to receive the tokens.

Like minhhn2910 said , since you don't have a public or external `mint` function, you cannot create more tokens. Your `INITIAL_SUPPLY` is your maximum and final `totalSupply_` (since you cannot burn nor send to the 0 address neither).

The only thing you can do is manually distribute tokens from the deployer address, or have the deployer address allow an other address to distribute its tokens on its behalf.

On top of that there are quite a lot of things to say about this contract:

• Some bad practices (constant variables are CAPITAL_CASE, ERC20 metada shouldn't be hardcoded but given as constructor input ...)
• missing IERC165 and IERC20...
• When using versions greater than 0.8 you don't need SafeMaths library since overflow and underflow checks are integrated.
• Over splitting functionalities in contracts isn't recommended and
• Contracts that define function headers but don't implement them are generally defined as Interfaces.