DepositContract

// Submitted by EthereumHistory (ethereumhistory.com)
pragma solidity ^0.4.17;

contract iERC20Token {
    function transfer(address _to, uint256 _value) public returns (bool success);
    function balanceOf(address _owner) public view returns (uint256 balance);
}

contract ERC1155 {
    function safeTransfer(address _to, uint256 _id, uint256 _value, bytes _data) external;
    function balanceOf(uint256 _id, address _owner) external view returns (uint256);
}

contract ERC721Basic {
    function balanceOf(address _owner) public view returns (uint256 _balance);
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) public;
}

contract AccessManager {
    function isServer(address sender) public view returns (bool);
    function isPopulous(address sender) public view returns (bool);
}

contract withAccessManager {
    AccessManager public AM;
    modifier onlyServer { require(AM.isServer(msg.sender) == true); _; }
    modifier onlyServerOrOnlyPopulous {
        require(AM.isServer(msg.sender) == true || AM.isPopulous(msg.sender) == true); _;
    }
    function withAccessManager(address _accessManager) public { AM = AccessManager(_accessManager); }
    function updateAccessManager(address _accessManager) public onlyServer { AM = AccessManager(_accessManager); }
}

contract DepositContract is withAccessManager {

    bytes32 public clientId;
    uint256 public version = 2;

    event EtherTransfer(address to, uint256 value);

    function DepositContract(bytes32 _clientId, address accessManager) public withAccessManager(accessManager) {
        clientId = _clientId;
    }

    function transfer(address populousTokenContract, address _to, uint256 _value) public
        onlyServerOrOnlyPopulous returns (bool success)
    {
        return iERC20Token(populousTokenContract).transfer(_to, _value);
    }

    function transferERC1155(address _erc1155Token, address _to, uint256 _id, uint256 _value)
        public onlyServerOrOnlyPopulous returns (bool success) {
        ERC1155(_erc1155Token).safeTransfer(_to, _id, _value, "");
        return true;
    }

    function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) public returns(bytes4) {
        return 0x150b7a02;
    }

    function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _value, bytes _data) public returns(bytes4) {
        return 0xf23a6e61;
    }

    function transferERC721(
        address erc721Token,
        address _to,
        uint256 _tokenId
    )
        public onlyServerOrOnlyPopulous returns (bool success)
    {
        ERC721Basic(erc721Token).safeTransferFrom(this, _to, _tokenId, "");
        return true;
    }

    function transferEther(address _to, uint256 _value) public
        onlyServerOrOnlyPopulous returns (bool success)
    {
        require(this.balance >= _value);
        require(_to.send(_value) == true);
        EtherTransfer(_to, _value);
        return true;
    }

    function balanceOf(address populousTokenContract) public view returns (uint256) {
        if (populousTokenContract == address(0)) {
            return address(this).balance;
        } else {
            return iERC20Token(populousTokenContract).balanceOf(this);
        }
    }

    function balanceOfERC721(address erc721Token) public view returns (uint256) {
        return ERC721Basic(erc721Token).balanceOf(this);
    }

    function balanceOfERC1155(address erc1155Token, uint256 _id) external view returns (uint256) {
        return ERC1155(erc1155Token).balanceOf(_id, this);
    }

    function getVersion() public view returns (uint256) {
        return version;
    }

    function getClientId() public view returns (bytes32 _clientId) {
        return clientId;
    }
}