Invocar contrato inteligente por dirección, desde otro contrato

Estoy probando contratos inteligentes de editor-suscriptor en ganache.

Tanto el editor como el suscriptor funcionan de forma independiente, pero cuando intento invocar al suscriptor del editor a través de la dirección del contrato, aparece el siguiente error :

"Error: Excepción de máquina virtual al procesar la transacción: revertir".

Estuve buscando en la red, pero no encontré ninguna solución.

Aquí está mi código:

Productor.sol

//Mocking subscriber contract

contract Receiver {

function notify(uint count) returns(uint);

function getCurrentCounter() constant returns(uint);

}

//Publisher

contract Producer {

uint private count;
uint private subscriberCount;
mapping(uint => Subscriber) subscribers;
event CountIncreased(uint num);

struct Subscriber {
    string subscriberName;
    address subscriberAddress;
}

function Producer() {
    count = 0;
    subscriberCount = 0;
}

function increaseCount() returns(uint,address) {
    count++;
    Receiver receiver = Receiver(subscribers[0].subscriberAddress);
    receiver.notify(count);
    CountIncreased(count);
    return (count,subscribers[0].subscriberAddress);
}

function addSubscriber(string name, address subAddress) {
    subscriberCount++;
    subscribers[subscriberCount].subscriberName = name ;
    subscribers[subscriberCount].subscriberAddress = subAddress ;
}

function removeSubscriber(string subscriberName) {
    for (uint i=0; i<subscriberCount; i++) {
        Subscriber sub = subscribers[i];
        if(keccak256(sub.subscriberName) == keccak256(subscriberName)) {
            delete subscribers[i];
            subscriberCount--;
        }
    }

}


}

Suscriptor.sol

pragma solidity ^0.4.0;

contract Bookkeeping {

uint counter;

function Bookkeeping() {
    counter = 0;
}

function notify(uint count) returns(uint) {
    counter = count+5;
    return counter;
}

function getCurrentCounter() constant returns(uint) {
    return counter;
}


}