Contrato que no utiliza contratos de proxy actualizados

Hay 2 contratos Ae importaciones , donde hay una biblioteca que Bse puede actualizar. Para lograr esto, intenté reemplazarlo con un contrato de proxy y un contrato de delegado.ABBB

Ahora tenemos contratos Foo, que importa contrato de proxy Bar, apuntando a contrato delegado ZeroDelegate.

foo.sol

pragma solidity ^0.4.18;

import './Bar.sol';

contract Foo {
    uint storageData;
    Bar bar;
    address barContractAddress;

    constructor(address _barContractAddress) public {
        barContractAddress = _barContractAddress;
    }

    function set(uint x) public {
        storageData = x;
    }

    function get() view public returns (uint) {
        return storageData;
    }

    function baz() public returns (uint) {
        bar = Bar(barContractAddress);
        storageData = bar.baz(storageData);
    }

}

bar.sol

pragma solidity ^0.4.18;

import './Proxy.sol';

contract Bar is Proxy {
    function baz(uint x) public returns (uint) {
        return  x * x;
    }
}

ZeroDelegate.sol

pragma solidity ^0.4.18;

contract ZeroDelegate {
    function baz(uint x) public returns (uint) {
        return x * 0;
    }
}

Proxy.sol

pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/ownership/Ownable.sol";

contract Proxy is Ownable {

    event Upgraded(address indexed implementation);

    address internal _implementation;

    function implementation() public view returns (address) {
        return _implementation;
    }

    function upgradeTo(address impl) public onlyOwner {
        require(_implementation != impl);
        _implementation = impl;
        emit Upgraded(impl);
    }

    function () payable public {
        address _impl = implementation();
        require(_impl != address(0));
        bytes memory data = msg.data;

        assembly {
            let result := delegatecall(gas, _impl, add(data, 0x20), mload(data), 0, 0)
            let size := returndatasize
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)
            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

Ahora primero implementamos los contratos Foo, Bar, ZeroDelegate.

bar = await Bar.new()
foo = await Foo.new(bar.address)
zeroDelegate = await ZeroDelegate.new()

Y foo.baz()cuadra el número 2 a 4.

x = await foo.baz()
console.log(x.toNumber())  // 4

A continuación, actualizamos el Barcontrato a ZeroDelegate, pero foo.baz()igual cuadramos el número 4 a 16

await bar.upgradeTo(zeroDelegate.address)
bar = _.extend(bar, ZeroDelegate.at(bar.address))
await foo.baz()
x = await foo.get()
console.log(x.toNumber())  // 16, but expects 0

Sin embargo, si tuviéramos que volver a implementar Fooel contrato, utiliza el actualizado Bar. ¿Por qué es esto y cómo podemos permitir Fooque usemos las Barfunciones actualizadas sin tener que volver a implementar Foo, lo que anula el propósito de usar un contrato actualizable?

foo = await Foo.new(bar.address)
await foo.baz()
x = await foo.get()
console.log(x.toNumber())  // 0