Unbehandelter Ablehnungsfehler: Konnte uint256 nicht von ABI entschlüsseln

Ich arbeite daran, einen Beispielvertrag mit NodeJS, Web3 und Solc zu verwenden, aber ich bin auf einen Fehler gestoßen, dass die angegebene Adresse in dem von mir erstellten Vertrag nicht entschlüsselt werden konnte. Mache ich etwas falsch? Hier ist der JS-Code, an dem ich arbeite

const Web3  = require('web3');
const fs    = require('fs');
const solc  = require('solc');

let web3 = new Web3();
web3.setProvider(new web3.providers.HttpProvider('http://localhost:8545'));

const source = fs.readFileSync(__dirname + '/solidity/Token.sol');
const output = solc.compile(source.toString(), 1);
const bytecode = output.contracts[':Token'].bytecode;
const abi = JSON.parse(output.contracts[':Token'].interface);

const contract = new web3.eth.Contract(abi, '0x5bbf74f1e804bfe671d55cd6b9f3ada66568d5dd', {
  from: web3.eth.coinbase,
  gasPrice: 90000*2
});

contract.methods.totalSupply().call().then(function (err, result) {
  console.log('error', err);
  console.log('result', result);
});

Hier ist der Solidity-Code, den ich verwende.

pragma solidity ^0.4.4;

contract Token {
    // stores the balances of the addresses
    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) approved;

    // number of tokens in circulation
    uint supply;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    function Token() {
        // constructor
        // balances[tx.origin] = 10000;
    }

    function totalSupply() constant returns (uint) {
        return supply;
    }

    function balanceOf(address _owner) constant returns (uint balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint _value) returns (bool success) {
        if (balances[msg.sender] >= _value
            && _value > 0
        ) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;

            // trigger an event
            Transfer(msg.sender, _to, _value);
            return true;
        }

        return false;
    }

    // sets how many can a spender spend from a certain address
    function approve(address _spender, uint _value) returns (bool success) {
        if (balances[msg.sender] > _value) {
            approved[msg.sender][_spender] = _value;
            return true;
        }

        return false;
    }

    // check the value of the spender can spend
    function allowance(address _owner, address _spender) constant returns (uint remaining) {
        return approved[_owner][_spender];
    }

    // transfer the approved value to spend
    function transferFrom(address _from, address _to, uint _value) constant returns (bool success) {
        if (balances[_from] >= _value
            && approved[_from][msg.sender] >= _value
            && _value > 0
        ) {
            balances[_from] -= _value;
            approved[_from][msg.sender] -= _value;


            balances[_to] += _value;
            return true;
        }

        return false;
    }
}

PS: Ich verwende testrpcals meinen Ethereum-Anbieter.