BalanceOf() von ERC20 kann nicht von einem anderen (ERC20)-Vertrag aufgerufen werden

Es ist mir gelungen, die Funktion transfer() des Tokens aus meinem Vertrag zu verwenden, die Funktion balanceOf() gibt jedoch nur 0 zurück. (oder es scheint auf MyEtherWallet)

Ich habe einen Fall getestet, in dem der Smart Contract ein Token von EOA (Bittrex-Konto) erhält und auf ein anderes EOA (MyEtherWallet-Konto) überträgt.

Also habe ich meinen Smart Contract unten von MyEtherWallet bereitgestellt und Tokens (in diesem Fall Golem) an diesen Vertrag gesendet.

Dann habe ich die Funktion transfer() des Tokens (Golem) aufgerufen und den Token erfolgreich auf mein MyEtherWallet-Konto übertragen.

Ich habe den Kontostand überprüft, indem ich den Vertrag des (Golem-)Tokens auf Etherscan besucht habe, der erfolgreich auf mein Konto (MyEtherWallet-Konto) übertragen wurde.

Wenn ich jedoch versuche, den Kontostand des Tokens aus meinem Vertrag auszulesen, zeigt er nur 0 an.

Ich dachte, dies läge an den Dezimalstellen, also habe ich versucht, zu multiplizieren und den Betrag zu dividieren, der von der Funktion balanceOf () zurückgegeben worden wäre. Allerdings funktioniert keiner von ihnen. Es zeigt nur 0 an.

Ich bin hier so verloren und bitte um die Hilfe eines fortgeschrittenen Solidity-Entwicklers. Was kann ich tun, um einen Vertrag abzuschließen, der das Guthaben des Tokens liest?

Danke fürs Zuhören.

Hier ist der intelligente Vertragscode, den ich erstellt habe.

PS Dachte, das Problem sei konstant , habe versucht, View zu verwenden, hat nicht funktioniert. Außerdem hat dieser Code keine Funktion, die das zurückgegebene Guthaben multipliziert.

pragma solidity ^0.4.24;

contract ERC20Basic{

function balanceOf(address _owner) external constant returns (uint256 balance);
function transfer(address to, uint256 value) public returns (bool);


}

library SafeMath {//SafeMath Code}

contract TokenTransferContract{

using SafeMath for uint256;

address _owner;
address _tokenAddress;
ERC20Basic erc20Instance;

constructor () public {

    _owner = msg.sender; //Contract distributor is the owner of this contract.

}

// Setting the instance to call functions from different contract (In this case ERC20 Token's function)

function setTokenInstance(address _tokenContractAddress) public {

    _tokenAddress = _tokenContractAddress;
    erc20Instance = ERC20Basic(_tokenContractAddress);

}

//transfer function works.

function transferContractTokenToOwner(uint256 _tokenAmount) public {
    require(_owner == msg.sender);

    erc20Instance.transfer(_owner, _tokenAmount); //Transfering the amount of token that was allocated with the address of this(UserTokenWalletContract) address to Owner(EOA).

}

function getAmountOfTokenOfOwner() view public returns (uint256 _amount){
    require(_owner == msg.sender);

    _amount = (erc20Instance.balanceOf(_owner)).div(1000000000000000000);

}

function getAmountOfTokenOfContract() view public returns (uint256 _amount){

    require(_owner == msg.sender);

    _amount = (erc20Instance.balanceOf(address(this))).div(1000000000000000000);

}

 function noneDecimalGetAmountOfTokenOfOwner() view public returns (uint256 _amount){
    require(_owner == msg.sender);

    _amount = erc20Instance.balanceOf(_owner);

}

function noneDecimalgetAmountOfTokenOfWalletContract() view public returns (uint256 _amount){
    require(_owner == msg.sender);

    _amount = erc20Instance.balanceOf(address(this));

}


function getOwnerAddress() view public returns (address _ownerAddress){
    _ownerAddress = _owner;

}

function getContractAddress() view public returns (address _contractAddress){
    _contractAddress = address(this);

}

function getContractInstanceAddress() view public returns (address _contractInstanceAddress){ 
    _contractInstanceAddress = _tokenAddress;

}

}