Cómo crear un método que llame a los tokens restantes en el contrato de depósito en garantía

Estoy usando Mist, en la red en solitario.

Se produjo un error durante el proceso de creación de depósito en garantía después de crear el token ERC20:

Error de compilación:

Ficha ERC20 CÓDIGO:

pragma solidity ^0.4.16;

interface tokenRecipient { function receiveApproval(address _from, uint256 
_value, address _token, bytes _extraData) public; }

contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 0;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;

// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);

// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);

/**
 * Constrctor function
 *
 * Initializes contract with initial supply tokens to the creator of the contract
 */
function TokenERC20(
    uint256 initialSupply,
    string tokenName,
    string tokenSymbol
) public {
    totalSupply = initialSupply * 10 ** uint256(decimals);  // Update total supply with the decimal amount
    balanceOf[msg.sender] = totalSupply;                // Give the creator all initial tokens
    name = tokenName;                                   // Set the name for display purposes
    symbol = tokenSymbol;                               // Set the symbol for display purposes
}

/**
 * Internal transfer, only can be called by this contract
 */
function _transfer(address _from, address _to, uint _value) internal {
    // Prevent transfer to 0x0 address. Use burn() instead
    require(_to != 0x0);
    // Check if the sender has enough
    require(balanceOf[_from] >= _value);
    // Check for overflows
    require(balanceOf[_to] + _value > balanceOf[_to]);
    // Save this for an assertion in the future
    uint previousBalances = balanceOf[_from] + balanceOf[_to];
    // Subtract from the sender
    balanceOf[_from] -= _value;
    // Add the same to the recipient
    balanceOf[_to] += _value;
    Transfer(_from, _to, _value);
    // Asserts are used to use static analysis to find bugs in your code. They should never fail
    assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}

/**
 * Transfer tokens
 *
 * Send `_value` tokens to `_to` from your account
 *
 * @param _to The address of the recipient
 * @param _value the amount to send
 */
function transfer(address _to, uint256 _value) public {
    _transfer(msg.sender, _to, _value);
}

/**
 * Transfer tokens from other address
 *
 * Send `_value` tokens to `_to` on behalf of `_from`
 *
 * @param _from The address of the sender
 * @param _to The address of the recipient
 * @param _value the amount to send
 */
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    require(_value <= allowance[_from][msg.sender]);     // Check allowance
    allowance[_from][msg.sender] -= _value;
    _transfer(_from, _to, _value);
    return true;
}

/**
 * Set allowance for other address
 *
 * Allows `_spender` to spend no more than `_value` tokens on your behalf
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 */
function approve(address _spender, uint256 _value) public
    returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    return true;
}

/**
 * Set allowance for other address and notify
 *
 * Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 * @param _extraData some extra information to send to the approved contract
 */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
    public
    returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }
}

/**
 * Destroy tokens
 *
 * Remove `_value` tokens from the system irreversibly
 *
 * @param _value the amount of money to burn
 */
function burn(uint256 _value) public returns (bool success) {
    require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
    balanceOf[msg.sender] -= _value;            // Subtract from the sender
    totalSupply -= _value;                      // Updates totalSupply
    Burn(msg.sender, _value);
    return true;
}

/**
 * Destroy tokens from other account
 *
 * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
 *
 * @param _from the address of the sender
 * @param _value the amount of money to burn
 */
function burnFrom(address _from, uint256 _value) public returns (bool success) {
    require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
    require(_value <= allowance[_from][msg.sender]);    // Check allowance
    balanceOf[_from] -= _value;                         // Subtract from the targeted balance
    allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
    totalSupply -= _value;                              // Update totalSupply
    Burn(_from, _value);
    return true;
}
}

"ESCROW" CODE:

pragma solidity ^0.4.18;


contract Owned {

address public owner;   

event TransferOwnerShip(address oldaddr, address newaddr);


modifier onlyOwner {require(msg.sender == owner);_;}


function Owned() public {
    owner = msg.sender;
}

function transferOwnership(address newOwner) onlyOwner public {
    address oldaddr = owner;
    owner = newOwner;
    TransferOwnerShip(oldaddr, owner);
}
}

interface token {
    function transfer(address receiver, uint amount) public;
}


contract Escrow is Owned {

token public tokenReward; //토큰
uint256 public salesVolume; //판매량
uint256 public sellingPrice; //판매가격
uint256 public deadline;     //기한
bool public isOpened;     //에스크로 개시 플래그

mapping(address => uint256) public balanceOf;

//(3)이벤트열람
event EscrowStart(uint salesVolume, uint sellingPrice, uint deadline, address beneficiary);
event ConfirmedPayment(address addr, uint amount);

//(4)생성자
function Escrow(
    address addressOfTokenUsedAsReward,
    uint256 _salesVolume,
    uint256 priceInEther

) public {
    tokenReward = token(addressOfTokenUsedAsReward);
    salesVolume = _salesVolume;
    sellingPrice = priceInEther * 1 ether;
}

//(5)이름없는함수(Ether 수령)
function () public payable {
    //개시 전 또는 기한이 끝난 경우에는 예외 처리
    require(!isOpened || now >= deadline);

    //판매 가격 미만인 경우 예외 처리
    uint amount = msg.value;
    require(amount < sellingPrice);

    ////보내는 사람에게 토큰을 전달하고 에스크로 개시 플래그를 false로 설정
    tokenReward.transfer(msg.sender, salesVolume);
    isOpened = false;
    ConfirmedPayment(msg.sender, amount);

}

//(6)개시(토큰이 예정 수 이상이라면 개시)
function start(uint256 _durationInMinutes) public {
    require(tokenReward == address(0) || salesVolume == 0 || sellingPrice == 0 || deadline !=0);
    if(tokenReward.balanceOf(this) >= salesVolume){
        deadline = now + _durationInMinutes * 1 minutes;
        isOpened = true;
        EscrowStart(salesVolume, sellingPrice, deadline, owner);
    }

}
//(7)남은 시간 확인용 메서드(분 단위)
function getRemainingTime() public constant returns(uint min){
    if(now < deadline) {
        min = (deadline - now) / (1 minutes);
    }
}
//(8)종료
function close() public {
    //토큰을 소유자에게 전송
   tokenReward.transfer(owner, tokenReward.balanceOf(this));
   //계약을 파기(해당 계약이 보유하고 있는 Ether는 소유자에게 전송)
   selfdestruct(owner);
}

}

Por favor, avíseme si necesita editar o agregar algo.