fix all the flow

.flowconfig

@@ -17,6 +17,7 @@
 ./src/flowtype/npm/react-redux_v5.x.x.js
 ./src/flowtype/npm/react-router_v4.x.x.js
 ./src/flowtype/npm/react-router-dom_v4.x.x.js
+; ./src/flowtype/npm/react-intl_v2.x.x.js // TODO: uncomment to get proper flow support for intl (needs some flow fixing) 
 ./src/flowtype/npm/connected-react-router.js
 ./src/flowtype/npm/bignumber.js
 ./src/flowtype/npm/ethereum-types.js

package.json

@@ -123,7 +123,7 @@
         "eslint-plugin-prettier": "^3.0.1",
         "eslint-plugin-react": "^7.12.4",
         "file-loader": "3.0.1",
-        "flow-bin": "0.75.0",
+        "flow-bin": "0.90",
         "jest": "^24.1.0",
         "prettier": "^1.16.4",
         "prettier-eslint": "^8.8.2",

src/components/Footer/index.js

@@ -7,16 +7,24 @@ import { Link, colors } from 'trezor-ui-components';
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { FormattedMessage } from 'react-intl';
+import type { State, Dispatch } from 'flowtype';
 
 import { FONT_SIZE, SCREEN_SIZE, FOOTER_HEIGHT } from 'config/variables';
 import * as LogActions from 'actions/LogActions';
 import l10nMessages from './index.messages';
 
-type Props = {
+type OwnProps = {|
-    opened: boolean,
     isLanding: boolean,
-    toggle: () => any,
+|};
-};
+type StateProps = {|
+    opened: boolean,
+|};
+
+type DispatchProps = {|
+    toggle: typeof LogActions.toggle,
+|};
+
+type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
 const Wrapper = styled.div`
     width: 100%;
@@ -134,15 +142,15 @@ Footer.propTypes = {
     toggle: PropTypes.func.isRequired,
 };
 
-const mapStateToProps = state => ({
+const mapStateToProps = (state: State): StateProps => ({
     opened: state.log.opened,
 });
 
-const mapDispatchToProps = dispatch => ({
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
     toggle: bindActionCreators(LogActions.toggle, dispatch),
 });
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
     mapStateToProps,
     mapDispatchToProps
 )(Footer);

src/components/Header/components/LanguagePicker/Container.js

@@ -1,41 +1,33 @@
 /* @flow */
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
-import { withRouter } from 'react-router-dom';
 
 import * as WalletActions from 'actions/WalletActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 
 import LanguagePicker from './index';
 
-type StateProps = {
+type StateProps = {|
     language: string,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     fetchLocale: typeof WalletActions.fetchLocale,
-};
+|};
 
-type OwnProps = {};
+type OwnProps = {||};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...StateProps, ...DispatchProps, ...OwnProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     language: state.wallet.language,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     fetchLocale: bindActionCreators(WalletActions.fetchLocale, dispatch),
 });
 
-export default withRouter(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
-    connect(
+    mapStateToProps,
-        mapStateToProps,
+    mapDispatchToProps
-        mapDispatchToProps
+)(LanguagePicker);
-    )(LanguagePicker)
-);

src/components/Log/index.js

@@ -12,12 +12,18 @@ import * as LogActions from 'actions/LogActions';
 import type { State, Dispatch } from 'flowtype';
 import l10nMessages from './index.messages';
 
-type Props = {
+type OwnProps = {||};
+type StateProps = {|
     log: $ElementType<State, 'log'>,
+|};
+
+type DispatchProps = {|
     toggle: typeof LogActions.toggle,
     copyToClipboard: typeof LogActions.copyToClipboard,
     resetCopyState: typeof LogActions.resetCopyState,
-};
+|};
+
+type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
 const Wrapper = styled.div`
     position: relative;
@@ -64,7 +70,7 @@ const ButtonCopy = styled(Button)`
     margin-top: 10px;
 `;
 
-const Log = (props: Props): ?React$Element<string> => {
+const Log = (props: Props) => {
     if (!props.log.opened) return null;
 
     const copyBtn = (
@@ -103,11 +109,11 @@ const Log = (props: Props): ?React$Element<string> => {
     );
 };
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
-    (state: State) => ({
+    (state: State): StateProps => ({
         log: state.log,
     }),
-    (dispatch: Dispatch) => ({
+    (dispatch: Dispatch): DispatchProps => ({
         toggle: bindActionCreators(LogActions.toggle, dispatch),
         copyToClipboard: bindActionCreators(LogActions.copyToClipboard, dispatch),
         resetCopyState: bindActionCreators(LogActions.resetCopyState, dispatch),

src/components/modals/Container.js

@@ -6,14 +6,13 @@ import { withRouter } from 'react-router-dom';
 import ModalActions from 'actions/ModalActions';
 import ReceiveActions from 'actions/ReceiveActions';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 
 import Modal from './index';
 
-type OwnProps = {};
+type OwnProps = {||};
 
-type StateProps = {
+type StateProps = {|
     modal: $ElementType<State, 'modal'>,
     accounts: $ElementType<State, 'accounts'>,
     devices: $ElementType<State, 'devices'>,
@@ -24,18 +23,16 @@ type StateProps = {
     receive: $ElementType<State, 'receive'>,
     localStorage: $ElementType<State, 'localStorage'>,
     wallet: $ElementType<State, 'wallet'>,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     modalActions: typeof ModalActions,
     receiveActions: typeof ReceiveActions,
-};
+|};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     modal: state.modal,
     accounts: state.accounts,
     devices: state.devices,
@@ -48,15 +45,13 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     wallet: state.wallet,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     modalActions: bindActionCreators(ModalActions, dispatch),
     receiveActions: bindActionCreators(ReceiveActions, dispatch),
 });
 
 // export default connect(mapStateToProps, mapDispatchToProps)(Modal);
-export default withRouter(
+export default withRouter<OwnProps>(
     connect(
         mapStateToProps,
         mapDispatchToProps

src/components/modals/QrModal/index.js

@@ -6,6 +6,7 @@ import QrReader from 'react-qr-reader';
 import styled from 'styled-components';
 import { FormattedMessage, injectIntl } from 'react-intl';
 import { Link, Icon, P, H5, icons, colors } from 'trezor-ui-components';
+import type { IntlShape } from 'react-intl';
 
 import { parseUri } from 'utils/cryptoUriParser';
 import type { parsedURI } from 'utils/cryptoUriParser';
@@ -55,7 +56,7 @@ type Props = {
     onScan: (data: parsedURI) => any,
     onError?: (error: any) => any,
     onCancel?: $ElementType<$ElementType<BaseProps, 'modalActions'>, 'onCancel'>,
-    intl: any,
+    intl: IntlShape,
 };
 
 type State = {

src/components/modals/device/WalletType/index.js

@@ -3,6 +3,7 @@
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import styled, { css } from 'styled-components';
+import type { IntlShape } from 'react-intl';
 
 import { H5, P, Button, Tooltip, Link, Icon, icons, colors } from 'trezor-ui-components';
 
@@ -15,7 +16,7 @@ import l10nMessages from './index.messages';
 import type { Props as BaseProps } from '../../Container';
 
 type Props = {
-    intl: any,
+    intl: IntlShape,
     device: TrezorDevice,
     onWalletTypeRequest: $ElementType<
         $ElementType<BaseProps, 'modalActions'>,

src/components/notifications/App/components/UpdateFirmware/index.js

@@ -5,11 +5,16 @@ import l10nCommonMessages from 'views/common.messages';
 import { withRouter } from 'react-router-dom';
 import { matchPath } from 'react-router';
 import { getPattern } from 'support/routes';
-import type { Props } from '../../index';
+import type { ContextRouter } from 'react-router';
+import type { Props as BaseProps } from '../../index';
 
 import l10nMessages from './index.messages';
 
-export default withRouter((props: Props & { location: any }) => {
+type OwnProps = {||};
+
+export type Props = {| ...OwnProps, ...BaseProps |};
+
+const UpdateFirmware = (props: {| ...Props, ...ContextRouter |}) => {
     const { selectedDevice } = props.wallet;
     const outdated =
         selectedDevice && selectedDevice.features && selectedDevice.firmware === 'outdated';
@@ -36,4 +41,6 @@ export default withRouter((props: Props & { location: any }) => {
             ]}
         />
     );
-});
+};
+
+export default withRouter<{| ...Props |}>(UpdateFirmware);

src/components/notifications/App/index.js

@@ -4,32 +4,33 @@ import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 
 import * as NotificationActions from 'actions/NotificationActions';
 import * as RouterActions from 'actions/RouterActions';
 
+import type { intlShape } from 'react-intl';
 import OnlineStatus from './components/OnlineStatus';
 import UpdateBridge from './components/UpdateBridge';
 import UpdateFirmware from './components/UpdateFirmware';
 import NoBackup from './components/NoBackup';
 
-export type StateProps = {
+type OwnProps = {|
+    intl: intlShape,
+|};
+
+export type StateProps = {|
     connect: $ElementType<State, 'connect'>,
     wallet: $ElementType<State, 'wallet'>,
     children?: React.Node,
-};
+|};
 
-export type DispatchProps = {
+export type DispatchProps = {|
     close: typeof NotificationActions.close,
     routerActions: typeof RouterActions,
-};
+|};
-type OwnProps = {
-    intl: any,
-};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
 const Notifications = (props: Props) => (
     <React.Fragment>
@@ -40,22 +41,18 @@ const Notifications = (props: Props) => (
     </React.Fragment>
 );
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     connect: state.connect,
     wallet: state.wallet,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     close: bindActionCreators(NotificationActions.close, dispatch),
     routerActions: bindActionCreators(RouterActions, dispatch),
 });
 
 export default injectIntl(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
         mapStateToProps,
         mapDispatchToProps
     )(Notifications)

src/components/notifications/Context/components/Static/index.js

@@ -12,7 +12,7 @@ export default (props: Props) => {
     const { selectedAccount } = props;
     const { account } = selectedAccount;
     const { location } = props.router;
-    const notifications: Array<Notification> = [];
+    const notifications = [];
 
     if (!location || !selectedAccount || !account) return null;
 

src/components/notifications/Context/index.js

@@ -3,8 +3,8 @@ import * as React from 'react';
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 
 import { reconnect } from 'actions/DiscoveryActions';
@@ -14,24 +14,25 @@ import StaticNotifications from './components/Static';
 import AccountNotifications from './components/Account';
 import ActionNotifications from './components/Action';
 
-export type StateProps = {
+type OwnProps = {|
+    intl: IntlShape,
+|};
+
+export type StateProps = {|
     router: $ElementType<State, 'router'>,
     notifications: $ElementType<State, 'notifications'>,
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     wallet: $ElementType<State, 'wallet'>,
     blockchain: $ElementType<State, 'blockchain'>,
     children?: React.Node,
-};
+|};
 
-export type DispatchProps = {
+export type DispatchProps = {|
     close: typeof NotificationActions.close,
     blockchainReconnect: typeof reconnect,
-};
+|};
-type OwnProps = {
-    intl: any,
-};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
 const Notifications = (props: Props) => (
     <React.Fragment>
@@ -41,9 +42,7 @@ const Notifications = (props: Props) => (
     </React.Fragment>
 );
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     router: state.router,
     notifications: state.notifications,
     selectedAccount: state.selectedAccount,
@@ -51,15 +50,13 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     blockchain: state.blockchain,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     close: bindActionCreators(NotificationActions.close, dispatch),
     blockchainReconnect: bindActionCreators(reconnect, dispatch),
 });
 
-export default injectIntl(
+export default injectIntl<OwnProps>(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
         mapStateToProps,
         mapDispatchToProps
     )(Notifications)

src/flowtype/npm/react-intl_v2.x.x.js

@@ -0,0 +1,259 @@
+/**
+ * Original implementation of this file by @marudor at https://github.com/marudor/flowInterfaces
+ * Copied here based on intention to merge with flow-typed expressed here:
+ * https://github.com/marudor/flowInterfaces/issues/6
+ */
+// Mostly from https://github.com/yahoo/react-intl/wiki/API#react-intl-api
+declare module "react-intl" {
+    import type { Element, ChildrenArray } from "react";
+  
+    declare type $npm$ReactIntl$LocaleData = {
+      locale: string,
+      [key: string]: any
+    };
+  
+    declare type $npm$ReactIntl$MessageDescriptor = {
+      id: string,
+      description?: string,
+      defaultMessage?: string
+    };
+  
+    declare type $npm$ReactIntl$IntlConfig = {
+      locale: string,
+      formats: Object,
+      messages: { [id: string]: string },
+  
+      defaultLocale?: string,
+      defaultFormats?: Object
+    };
+  
+    declare type $npm$ReactIntl$IntlProviderConfig = {
+      locale?: string,
+      formats?: Object,
+      messages?: { [id: string]: string },
+  
+      defaultLocale?: string,
+      defaultFormats?: Object
+    };
+  
+    declare type $npm$ReactIntl$IntlFormat = {
+      formatDate: (value: any, options?: Object) => string,
+      formatTime: (value: any, options?: Object) => string,
+      formatRelative: (value: any, options?: Object) => string,
+      formatNumber: (value: any, options?: Object) => string,
+      formatPlural: (value: any, options?: Object) => string,
+      formatMessage: (
+        messageDescriptor: $npm$ReactIntl$MessageDescriptor,
+        values?: Object
+      ) => string,
+      formatHTMLMessage: (
+        messageDescriptor: $npm$ReactIntl$MessageDescriptor,
+        values?: Object
+      ) => string
+    };
+  
+    declare type $npm$ReactIntl$IntlShape = $npm$ReactIntl$IntlConfig &
+      $npm$ReactIntl$IntlFormat & { now: () => number };
+  
+    declare type $npm$ReactIntl$DateTimeFormatOptions = {
+      localeMatcher?: "best fit" | "lookup",
+      formatMatcher?: "basic" | "best fit",
+  
+      timeZone?: string,
+      hour12?: boolean,
+  
+      weekday?: "narrow" | "short" | "long",
+      era?: "narrow" | "short" | "long",
+      year?: "numeric" | "2-digit",
+      month?: "numeric" | "2-digit" | "narrow" | "short" | "long",
+      day?: "numeric" | "2-digit",
+      hour?: "numeric" | "2-digit",
+      minute?: "numeric" | "2-digit",
+      second?: "numeric" | "2-digit",
+      timeZoneName?: "short" | "long"
+    };
+  
+    declare type $npm$ReactIntl$RelativeFormatOptions = {
+      style?: "best fit" | "numeric",
+      units?: "second" | "minute" | "hour" | "day" | "month" | "year"
+    };
+  
+    declare type $npm$ReactIntl$NumberFormatOptions = {
+      localeMatcher?: "best fit" | "lookup",
+  
+      style?: "decimal" | "currency" | "percent",
+  
+      currency?: string,
+      currencyDisplay?: "symbol" | "code" | "name",
+  
+      useGrouping?: boolean,
+  
+      minimumIntegerDigits?: number,
+      minimumFractionDigits?: number,
+      maximumFractionDigits?: number,
+      minimumSignificantDigits?: number,
+      maximumSignificantDigits?: number
+    };
+  
+    declare type $npm$ReactIntl$PluralFormatOptions = {
+      style?: "cardinal" | "ordinal"
+    };
+  
+    declare type $npm$ReactIntl$PluralCategoryString =
+      | "zero"
+      | "one"
+      | "two"
+      | "few"
+      | "many"
+      | "other";
+  
+    declare type $npm$ReactIntl$DateParseable = number | string | Date;
+    // PropType checker
+    declare function intlShape(
+      props: Object,
+      propName: string,
+      componentName: string
+    ): void;
+    declare function addLocaleData(
+      data: $npm$ReactIntl$LocaleData | Array<$npm$ReactIntl$LocaleData>
+    ): void;
+    declare function defineMessages<
+      T: { [key: string]: $Exact<$npm$ReactIntl$MessageDescriptor> }
+    >(
+      messageDescriptors: T
+    ): T;
+  
+    declare type InjectIntlProvidedProps = {
+      intl: $npm$ReactIntl$IntlShape
+    }
+  
+    declare type InjectIntlVoidProps = {
+      intl: $npm$ReactIntl$IntlShape | void
+    }
+  
+    declare type ComponentWithDefaultProps<DefaultProps: {}, Props: {}> =
+      | React$ComponentType<Props>
+      | React$StatelessFunctionalComponent<Props>
+      | ChildrenArray<void | null | boolean | string | number | Element<any>>;
+  
+    declare type InjectIntlOptions = {
+      intlPropName?: string,
+      withRef?: boolean
+    }
+  
+    declare class IntlInjectedComponent<TOwnProps, TDefaultProps> extends React$Component<TOwnProps> {
+      static WrappedComponent: Class<React$Component<TOwnProps & InjectIntlProvidedProps>>,
+      static defaultProps: TDefaultProps,
+      props: TOwnProps
+    }
+  
+    declare type IntlInjectedComponentClass<TOwnProps, TDefaultProps: {} = {}> = Class<
+      IntlInjectedComponent<TOwnProps, TDefaultProps>
+    >;
+  
+    declare function injectIntl<P: {}, Component: React$ComponentType<P>>(
+      WrappedComponent: Component,
+      options?: InjectIntlOptions,
+    ): React$ComponentType<
+      $Diff<React$ElementConfig<Component>, InjectIntlVoidProps>
+    >;
+  
+    declare function formatMessage(
+      messageDescriptor: $npm$ReactIntl$MessageDescriptor,
+      values?: Object
+    ): string;
+    declare function formatHTMLMessage(
+      messageDescriptor: $npm$ReactIntl$MessageDescriptor,
+      values?: Object
+    ): string;
+    declare function formatDate(
+      value: any,
+      options?: $npm$ReactIntl$DateTimeFormatOptions & { format: string }
+    ): string;
+    declare function formatTime(
+      value: any,
+      options?: $npm$ReactIntl$DateTimeFormatOptions & { format: string }
+    ): string;
+    declare function formatRelative(
+      value: any,
+      options?: $npm$ReactIntl$RelativeFormatOptions & {
+        format: string,
+        now: any
+      }
+    ): string;
+    declare function formatNumber(
+      value: any,
+      options?: $npm$ReactIntl$NumberFormatOptions & { format: string }
+    ): string;
+    declare function formatPlural(
+      value: any,
+      options?: $npm$ReactIntl$PluralFormatOptions
+    ): $npm$ReactIntl$PluralCategoryString;
+  
+    declare class FormattedMessage extends React$Component<
+      $npm$ReactIntl$MessageDescriptor & {
+        values?: Object,
+        tagName?: string,
+        children?:
+          | ((...formattedMessage: Array<React$Node>) => React$Node)
+          | (string => React$Node)
+      }
+    > {}
+    declare class FormattedHTMLMessage extends React$Component<
+      $npm$ReactIntl$DateTimeFormatOptions & {
+        values?: Object,
+        tagName?: string,
+        children?: (...formattedMessage: Array<React$Node>) => React$Node
+      }
+    > {}
+    declare class FormattedDate extends React$Component<
+      $npm$ReactIntl$DateTimeFormatOptions & {
+        value: $npm$ReactIntl$DateParseable,
+        format?: string,
+        children?: (formattedDate: string) => React$Node
+      }
+    > {}
+    declare class FormattedTime extends React$Component<
+      $npm$ReactIntl$DateTimeFormatOptions & {
+        value: $npm$ReactIntl$DateParseable,
+        format?: string,
+        children?: (formattedDate: string) => React$Node
+      }
+    > {}
+    declare class FormattedRelative extends React$Component<
+      $npm$ReactIntl$RelativeFormatOptions & {
+        value: $npm$ReactIntl$DateParseable,
+        format?: string,
+        updateInterval?: number,
+        initialNow?: $npm$ReactIntl$DateParseable,
+        children?: (formattedDate: string) => React$Node
+      }
+    > {}
+    declare class FormattedNumber extends React$Component<
+      $npm$ReactIntl$NumberFormatOptions & {
+        value: number | string,
+        format?: string,
+        children?: (formattedNumber: string) => React$Node
+      }
+    > {}
+    declare class FormattedPlural extends React$Component<
+      $npm$ReactIntl$PluralFormatOptions & {
+        value: number | string,
+        other: React$Node,
+        zero?: React$Node,
+        one?: React$Node,
+        two?: React$Node,
+        few?: React$Node,
+        many?: React$Node,
+        children?: (formattedPlural: React$Node) => React$Node
+      }
+    > {}
+    declare class IntlProvider extends React$Component<
+      $npm$ReactIntl$IntlProviderConfig & {
+        children?: React$Node,
+        initialNow?: $npm$ReactIntl$DateParseable
+      }
+    > {}
+    declare type IntlShape = $npm$ReactIntl$IntlShape;
+    declare type MessageDescriptor = $npm$ReactIntl$MessageDescriptor;
+  }

src/flowtype/npm/react-redux_v5.x.x.js

@@ -1,127 +1,275 @@
-// flow-typed signature: 59b0c4be0e1408f21e2446be96c79804
+/**
-// flow-typed version: 9092387fd2/react-redux_v5.x.x/flow_>=v0.54.x
+The order of type arguments for connect() is as follows:
 
-import type { Dispatch, Store } from 'redux';
+connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(…)
 
-declare module 'react-redux' {
+In Flow v0.89 only the first two are mandatory to specify. Other 4 can be repaced with the new awesome type placeholder:
-  /*
 
-    S = State
+connect<Props, OwnProps, _, _, _, _>(…)
-    A = Action
-    D = Dispatch
-    OP = OwnProps
-    SP = StateProps
-    DP = DispatchProps
 
-  */
+But beware, in case of weird type errors somewhere in random places
+just type everything and get to a green field and only then try to
+remove the definitions you see bogus.
 
-  declare type MapStateToProps<S, OP: Object, SP: Object> = (
+Decrypting the abbreviations:
-    state: S,
+  WC = Component being wrapped
-    ownProps: OP
+  S = State
-  ) => ((state: S, ownProps: OP) => SP) | SP;
+  D = Dispatch
+  OP = OwnProps
+  SP = StateProps
+  DP = DispatchProps
+  MP = Merge props
+  RSP = Returned state props
+  RDP = Returned dispatch props
+  RMP = Returned merge props
+  CP = Props for returned component
+  Com = React Component
+  ST = Static properties of Com
+  EFO = Extra factory options (used only in connectAdvanced)
+*/
+
+declare module "react-redux" {
+  // ------------------------------------------------------------
+  // Typings for connect()
+  // ------------------------------------------------------------
+
+  declare export type Options<S, OP, SP, MP> = {|
+    pure?: boolean,
+    withRef?: boolean,
+    areStatesEqual?: (next: S, prev: S) => boolean,
+    areOwnPropsEqual?: (next: OP, prev: OP) => boolean,
+    areStatePropsEqual?: (next: SP, prev: SP) => boolean,
+    areMergedPropsEqual?: (next: MP, prev: MP) => boolean,
+    storeKey?: string,
+  |};
 
-  declare type MapDispatchToProps<D, OP: Object, DP: Object> =
+  declare type MapStateToProps<-S, -OP, +SP> =
+    | ((state: S, ownProps: OP) => SP)
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (State, OwnProps) => (State, OwnProps) => StateProps
+    // and provide the StateProps type to the SP type parameter.
+    | ((state: S, ownProps: OP) => (state: S, ownProps: OP) => SP);
+
+  declare type Bind<D> = <A, R>((...A) => R) => (...A) => $Call<D, R>;
+
+  declare type MapDispatchToPropsFn<D, -OP, +DP> =
     | ((dispatch: D, ownProps: OP) => DP)
-    | DP;
+    // If you want to use the factory function but get a strange error
+    // like "function is not an object" then just type the factory function
+    // like this:
+    // const factory: (Dispatch, OwnProps) => (Dispatch, OwnProps) => DispatchProps
+    // and provide the DispatchProps type to the DP type parameter.
+    | ((dispatch: D, ownProps: OP) => (dispatch: D, ownProps: OP) => DP);
+
+  declare class ConnectedComponent<OP, +WC> extends React$Component<OP> {
+    static +WrappedComponent: WC;
+    getWrappedInstance(): React$ElementRef<WC>;
+  }
+  declare type Connector<P, OP, MP: P> = <WC: React$ComponentType<P>>(
+    WC,
+  ) => Class<ConnectedComponent<OP, WC>> & WC;
+
+  // No `mergeProps` argument
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    mapStateToProps?: null | void,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, {| ...OP, dispatch: D |}>,
+    // Got error like inexact OwnProps is incompatible with exact object type?
+    // Just make your OP parameter an exact object.
+  ): Connector<P, OP, {| ...OP, dispatch: D |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, -S, -D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps?: null | void,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP |}>,
+    // Got error like inexact OwnProps is incompatible with exact object type?
+    // Just make your OP parameter an exact object.
+  ): Connector<P, OP, {| ...OP, ...SP |}>;
+
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, {| ...OP, ...DP |}>,
+    // Got error like inexact OwnProps is incompatible with exact object type?
+    // Just make your OP parameter an exact object.
+  ): Connector<P, OP, {| ...OP, ...DP |}>;
+
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, {||}, {| ...OP, ...DP |}>,
+    // Got error like inexact OwnProps is incompatible with exact object type?
+    // Just make your OP parameter an exact object.
+  ): Connector<P, OP, {| ...OP, ...$ObjMap<DP, Bind<D>> |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP, ...DP |}>,
+    // Got error like inexact OwnProps is incompatible with exact object type?
+    // Just make your OP parameter an exact object.
+  ): Connector<P, OP, {| ...OP, ...SP, ...DP |}>;
+
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    // If you get error here try adding return type to your mapStateToProps function
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps?: null | void,
+    options?: ?Options<S, OP, SP, {| ...OP, ...SP, ...DP |}>,
+    // Got error like inexact OwnProps is incompatible with exact object type?
+    // Just make your OP parameter an exact object.
+  ): Connector<P, OP, {| ...OP, ...SP, ...$ObjMap<DP, Bind<D>> |}>;
+
+  // With `mergeProps` argument
 
-  declare type MergeProps<SP, DP: Object, OP: Object, P: Object> = (
+  declare type MergeProps<+P, -OP, -SP, -DP> = (
     stateProps: SP,
     dispatchProps: DP,
-    ownProps: OP
+    ownProps: OP,
   ) => P;
 
-  declare type Context = { store: Store<*, *> };
+  declare export function connect<-P, -OP, -SP: {||}, -DP: {||}, S, D>(
+    mapStateToProps: null | void,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, {||}, {| dispatch: D |}>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
 
-  declare type ComponentWithDefaultProps<DP: {}, P: {}, CP: P> = Class<React$Component<CP>> & { defaultProps: DP };
+  declare export function connect<-P, -OP, -SP, -DP: {||}, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: null | void,
+    // If you get error here try adding return type to you mapStateToProps function
+    mergeProps: MergeProps<P, OP, SP, {| dispatch: D |}>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
 
-  declare class ConnectedComponentWithDefaultProps<
+  // In this case DP is an object of functions which has been bound to dispatch
-    OP,
+  // by the given mapDispatchToProps function.
-    DP,
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
-    CP
+    mapStateToProps: null | void,
-  > extends React$Component<OP> {
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
-    static defaultProps: DP, // <= workaround for https://github.com/facebook/flow/issues/4644
+    mergeProps: MergeProps<P, OP, {||}, DP>,
-    static WrappedComponent: Class<React$Component<CP>>,
+    options?: ?Options<S, OP, {||}, P>,
-    getWrappedInstance(): React$Component<CP>,
+  ): Connector<P, OP, P>;
-    props: OP,
-    state: void
-  }
 
-  declare class ConnectedComponent<OP, P> extends React$Component<OP> {
+  // In this case DP is an object of action creators not yet bound to dispatch,
-    static WrappedComponent: Class<React$Component<P>>,
+  // this difference is not important in the vanila redux,
-    getWrappedInstance(): React$Component<P>,
+  // but in case of usage with redux-thunk, the return type may differ.
-    props: OP,
+  declare export function connect<-P, -OP, -SP: {||}, -DP, S, D>(
-    state: void
+    mapStateToProps: null | void,
-  }
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, {||}, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, {||}, P>,
+  ): Connector<P, OP, P>;
 
-  declare type ConnectedComponentWithDefaultPropsClass<OP, DP, CP> = Class<ConnectedComponentWithDefaultProps<OP, DP, CP>>;
+  // In this case DP is an object of functions which has been bound to dispatch
+  // by the given mapDispatchToProps function.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: MapDispatchToPropsFn<D, OP, DP>,
+    mergeProps: MergeProps<P, OP, SP, DP>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
 
-  declare type ConnectedComponentClass<OP, P> = Class<ConnectedComponent<OP, P>>;
+  // In this case DP is an object of action creators not yet bound to dispatch,
+  // this difference is not important in the vanila redux,
+  // but in case of usage with redux-thunk, the return type may differ.
+  declare export function connect<-P, -OP, -SP, -DP, S, D>(
+    mapStateToProps: MapStateToProps<S, OP, SP>,
+    mapDispatchToProps: DP,
+    mergeProps: MergeProps<P, OP, SP, $ObjMap<DP, Bind<D>>>,
+    options?: ?Options<S, OP, SP, P>,
+  ): Connector<P, OP, P>;
 
-  declare type Connector<OP, P> = (<DP: {}, CP: {}>(
+  // ------------------------------------------------------------
-    component: ComponentWithDefaultProps<DP, P, CP>
+  // Typings for Provider
-  ) => ConnectedComponentWithDefaultPropsClass<OP, DP, CP>) &
+  // ------------------------------------------------------------
-    ((component: React$ComponentType<P>) => ConnectedComponentClass<OP, P>);
 
-  declare class Provider<S, A> extends React$Component<{
+  declare export class Provider<Store> extends React$Component<{
-    store: Store<S, A>,
+    store: Store,
-    children?: any
+    children?: React$Node,
   }> {}
 
-  declare function createProvider(
+  declare export function createProvider(
     storeKey?: string,
-    subKey?: string
+    subKey?: string,
-  ): Provider<*, *>;
+  ): Class<Provider<*>>;
 
-  declare type ConnectOptions = {
+  // ------------------------------------------------------------
-    pure?: boolean,
+  // Typings for connectAdvanced()
-    withRef?: boolean
+  // ------------------------------------------------------------
-  };
 
-  declare type Null = null | void;
+  declare type ConnectAdvancedOptions = {
+    getDisplayName?: (name: string) => string,
+    methodName?: string,
+    renderCountProp?: string,
+    shouldHandleStateChanges?: boolean,
+    storeKey?: string,
+    withRef?: boolean,
+  };
 
-  declare function connect<A, OP>(
+  declare type SelectorFactoryOptions<Com> = {
-    ...rest: Array<void> // <= workaround for https://github.com/facebook/flow/issues/2360
+    getDisplayName: (name: string) => string,
-  ): Connector<OP, $Supertype<{ dispatch: Dispatch<A> } & OP>>;
+    methodName: string,
+    renderCountProp: ?string,
+    shouldHandleStateChanges: boolean,
+    storeKey: string,
+    withRef: boolean,
+    displayName: string,
+    wrappedComponentName: string,
+    WrappedComponent: Com,
+  };
 
-  declare function connect<A, OP>(
+  declare type MapStateToPropsEx<S: Object, SP: Object, RSP: Object> = (
-    mapStateToProps: Null,
+    state: S,
-    mapDispatchToProps: Null,
+    props: SP,
-    mergeProps: Null,
+  ) => RSP;
-    options: ConnectOptions
-  ): Connector<OP, $Supertype<{ dispatch: Dispatch<A> } & OP>>;
 
-  declare function connect<S, A, OP, SP>(
+  declare type SelectorFactory<
-    mapStateToProps: MapStateToProps<S, OP, SP>,
+    Com: React$ComponentType<*>,
-    mapDispatchToProps: Null,
+    Dispatch,
-    mergeProps: Null,
+    S: Object,
-    options?: ConnectOptions
+    OP: Object,
-  ): Connector<OP, $Supertype<SP & { dispatch: Dispatch<A> } & OP>>;
+    EFO: Object,
-
+    CP: Object,
-  declare function connect<A, OP, DP>(
+  > = (
-    mapStateToProps: Null,
+    dispatch: Dispatch,
-    mapDispatchToProps: MapDispatchToProps<A, OP, DP>,
+    factoryOptions: SelectorFactoryOptions<Com> & EFO,
-    mergeProps: Null,
+  ) => MapStateToPropsEx<S, OP, CP>;
-    options?: ConnectOptions
-  ): Connector<OP, $Supertype<DP & OP>>;
-
-  declare function connect<S, A, OP, SP, DP>(
-    mapStateToProps: MapStateToProps<S, OP, SP>,
-    mapDispatchToProps: MapDispatchToProps<A, OP, DP>,
-    mergeProps: Null,
-    options?: ConnectOptions
-  ): Connector<OP, $Supertype<SP & DP & OP>>;
 
-  declare function connect<S, A, OP, SP, DP, P>(
+  declare export function connectAdvanced<
-    mapStateToProps: MapStateToProps<S, OP, SP>,
+    Com: React$ComponentType<*>,
-    mapDispatchToProps: Null,
+    D,
-    mergeProps: MergeProps<SP, DP, OP, P>,
+    S: Object,
-    options?: ConnectOptions
+    OP: Object,
-  ): Connector<OP, P>;
+    CP: Object,
+    EFO: Object,
+    ST: { [_: $Keys<Com>]: any },
+  >(
+    selectorFactory: SelectorFactory<Com, D, S, OP, EFO, CP>,
+    connectAdvancedOptions: ?(ConnectAdvancedOptions & EFO),
+  ): (component: Com) => React$ComponentType<OP> & $Shape<ST>;
 
-  declare function connect<S, A, OP, SP, DP, P>(
+  declare export default {
-    mapStateToProps: MapStateToProps<S, OP, SP>,
+    Provider: typeof Provider,
-    mapDispatchToProps: MapDispatchToProps<A, OP, DP>,
+    createProvider: typeof createProvider,
-    mergeProps: MergeProps<SP, DP, OP, P>,
+    connect: typeof connect,
-    options?: ConnectOptions
+    connectAdvanced: typeof connectAdvanced,
-  ): Connector<OP, P>;
+  };
 }

src/reducers/index.js

@@ -2,6 +2,7 @@
 import { combineReducers } from 'redux';
 import { connectRouter } from 'connected-react-router';
 import type { State } from 'connected-react-router';
+import type { Action } from 'flowtype';
 
 import log from 'reducers/LogReducer';
 import localStorage from 'reducers/LocalStorageReducer';
@@ -60,8 +61,8 @@ export type Reducers = typeof reducers;
 type $ExtractFunctionReturn = <V>(v: (...args: any) => V) => V;
 export type ReducersState = $ObjMap<Reducers, $ExtractFunctionReturn>;
 
-export default (history: any) =>
+export default (history: Object) =>
-    combineReducers({
+    combineReducers<Reducers, Action>({
         ...reducers,
         router: connectRouter(history),
     });

src/store.js

@@ -12,11 +12,10 @@ import Raven from 'raven-js';
 import RavenMiddleware from 'redux-raven-middleware';
 import * as buildUtils from 'utils/build';
 
-import type { Action, GetState } from 'flowtype';
+import type { State, Action, Dispatch, GetState } from 'flowtype';
 
 export const history: History = createHistory({ queryKey: false });
 
-const initialState: any = {};
 const enhancers = [];
 
 const middlewares = [thunk, routerMiddleware(history)];
@@ -61,4 +60,4 @@ if (buildUtils.isDev()) {
     );
 }
 
-export default createStore(createRootReducer(history), initialState, composedEnhancers);
+export default createStore<State, Action, Dispatch>(createRootReducer(history), composedEnhancers);

src/support/ConnectedIntlProvider.js

@@ -2,7 +2,6 @@
 import * as React from 'react';
 import { connect } from 'react-redux';
 
-import type { MapStateToProps } from 'react-redux';
 import type { State } from 'flowtype';
 
 import { IntlProvider, addLocaleData } from 'react-intl';
@@ -43,20 +42,21 @@ addLocaleData([
     ...zh,
 ]);
 
-type OwnProps = {
+type OwnProps = {|
     children: React.Node,
-};
+|};
 
-type StateProps = {
+type StateProps = {|
     locale: string,
     messages: { [string]: string },
-};
+|};
 
-type Props = StateProps & OwnProps;
+type Props = {|
+    ...OwnProps,
+    ...StateProps,
+|};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     locale: state.wallet.language,
     messages: state.wallet.messages,
 });
@@ -71,7 +71,6 @@ const ReactIntlProvider = ({ children, locale, messages }: Props) => (
     </IntlProvider>
 );
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, _, State, _>(mapStateToProps)(
-    mapStateToProps,
+    ReactIntlProvider
-    null
+);
-)(ReactIntlProvider);

src/views/Landing/components/BetaDisclaimer/index.js

@@ -9,8 +9,19 @@ import { Button, Icon, P, H5, colors, icons } from 'trezor-ui-components';
 
 import { FONT_SIZE } from 'config/variables';
 import * as WalletActions from 'actions/WalletActions';
+import type { State, Dispatch } from 'flowtype';
 import l10nMessages from './index.messages';
 
+type OwnProps = {||};
+
+type StateProps = {||};
+
+type DispatchProps = {|
+    close: typeof WalletActions.hideBetaDisclaimer,
+|};
+
+type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
+
 const Wrapper = styled.div`
     width: 100%;
     min-height: 100vh;
@@ -50,7 +61,7 @@ const StyledIcon = styled(Icon)`
     top: -1px;
 `;
 
-const BetaDisclaimer = (props: { close: () => void }) => (
+const BetaDisclaimer = (props: Props) => (
     <Wrapper>
         <ModalWindow>
             <H5>
@@ -115,9 +126,9 @@ const BetaDisclaimer = (props: { close: () => void }) => (
     </Wrapper>
 );
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
     null,
-    (dispatch: Dispatch) => ({
+    (dispatch: Dispatch): DispatchProps => ({
         close: bindActionCreators(WalletActions.hideBetaDisclaimer, dispatch),
     })
 )(BetaDisclaimer);

src/views/Landing/views/Import/Container.js

@@ -4,39 +4,34 @@ import { connect } from 'react-redux';
 import { bindActionCreators } from 'redux';
 import * as RouterActions from 'actions/RouterActions';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import ImportView from './index';
 
-export type StateProps = {
+type OwnProps = {|
-    transport: $ElementType<$ElementType<State, 'connect'>, 'transport'>,
     children?: React.Node,
-};
+|};
+export type StateProps = {|
+    transport: $ElementType<$ElementType<State, 'connect'>, 'transport'>,
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     selectFirstAvailableDevice: typeof RouterActions.selectFirstAvailableDevice,
-};
+|};
-
-type OwnProps = {};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     transport: state.connect.transport,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     selectFirstAvailableDevice: bindActionCreators(
         RouterActions.selectFirstAvailableDevice,
         dispatch
     ),
 });
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
     mapStateToProps,
     mapDispatchToProps
 )(ImportView);

src/views/Landing/views/InstallBridge/Container.js

@@ -4,39 +4,34 @@ import { connect } from 'react-redux';
 import { bindActionCreators } from 'redux';
 import * as RouterActions from 'actions/RouterActions';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import InstallBridge from './index';
 
-export type StateProps = {
+type OwnProps = {|
-    transport: $ElementType<$ElementType<State, 'connect'>, 'transport'>,
     children?: React.Node,
-};
+|};
+export type StateProps = {|
+    transport: $ElementType<$ElementType<State, 'connect'>, 'transport'>,
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     selectFirstAvailableDevice: typeof RouterActions.selectFirstAvailableDevice,
-};
+|};
-
-type OwnProps = {};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...StateProps, ...DispatchProps, ...OwnProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     transport: state.connect.transport,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     selectFirstAvailableDevice: bindActionCreators(
         RouterActions.selectFirstAvailableDevice,
         dispatch
     ),
 });
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
     mapStateToProps,
     mapDispatchToProps
 )(InstallBridge);

src/views/Landing/views/Root/Container.js

@@ -2,11 +2,13 @@
 import * as React from 'react';
 import { connect } from 'react-redux';
 
-import type { MapStateToProps } from 'react-redux';
 import type { State } from 'flowtype';
 import RootView from './index';
 
-export type StateProps = {
+type OwnProps = {|
+    children?: React.Node,
+|};
+export type StateProps = {|
     localStorage: $ElementType<State, 'localStorage'>,
     modal: $ElementType<State, 'modal'>,
     wallet: $ElementType<State, 'wallet'>,
@@ -15,16 +17,13 @@ export type StateProps = {
     wallet: $ElementType<State, 'wallet'>,
     devices: $ElementType<State, 'devices'>,
     children?: React.Node,
-};
+|};
 
-type DispatchProps = {};
+type DispatchProps = {||};
-type OwnProps = {};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     localStorage: state.localStorage,
     modal: state.modal,
     wallet: state.wallet,
@@ -33,7 +32,6 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     devices: state.devices,
 });
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, _>(mapStateToProps)(
-    mapStateToProps,
+    RootView
-    null
+);
-)(RootView);

src/views/Wallet/components/LeftNavigation/Container.js

@@ -8,18 +8,15 @@ import * as TrezorConnectActions from 'actions/TrezorConnectActions';
 import * as DiscoveryActions from 'actions/DiscoveryActions';
 import * as RouterActions from 'actions/RouterActions';
 import * as ModalActions from 'actions/ModalActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 
 import type { StateProps, DispatchProps } from './components/common';
 
 import LeftNavigation from './index';
 
-type OwnProps = {};
+type OwnProps = {||};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     connect: state.connect,
     accounts: state.accounts,
     router: state.router,
@@ -31,9 +28,7 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     pending: state.pending,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     toggleDeviceDropdown: bindActionCreators(toggleDeviceDropdown, dispatch),
     addAccount: bindActionCreators(DiscoveryActions.addAccount, dispatch),
     acquireDevice: bindActionCreators(TrezorConnectActions.acquire, dispatch),
@@ -46,7 +41,7 @@ const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps>
     setHideBalance: bindActionCreators(setHideBalance, dispatch),
 });
 
-export default withRouter(
+export default withRouter<OwnProps>(
     connect(
         mapStateToProps,
         mapDispatchToProps

src/views/Wallet/components/LeftNavigation/components/DeviceMenu/index.js

@@ -109,7 +109,7 @@ class DeviceMenu extends PureComponent<Props> {
 
     mouseDownHandler: (event: MouseEvent) => void;
 
-    blurHandler: (event: FocusEvent) => void;
+    blurHandler: () => void;
 
     showDivider() {
         return this.props.devices.length > 1;

src/views/Wallet/components/LeftNavigation/components/common.js

@@ -6,7 +6,7 @@ import * as ModalActions from 'actions/ModalActions';
 import * as WalletActions from 'actions/WalletActions';
 import type { State } from 'flowtype';
 
-export type StateProps = {
+export type StateProps = {|
     connect: $ElementType<State, 'connect'>,
     accounts: $ElementType<State, 'accounts'>,
     router: $ElementType<State, 'router'>,
@@ -16,9 +16,9 @@ export type StateProps = {
     wallet: $ElementType<State, 'wallet'>,
     devices: $ElementType<State, 'devices'>,
     pending: $ElementType<State, 'pending'>,
-};
+|};
 
-export type DispatchProps = {
+export type DispatchProps = {|
     toggleDeviceDropdown: typeof WalletActions.toggleDeviceDropdown,
     toggleSidebar: typeof WalletActions.toggleSidebar,
     setHideBalance: typeof WalletActions.setHideBalance,
@@ -29,6 +29,6 @@ export type DispatchProps = {
     gotoDeviceSettings: typeof RouterActions.gotoDeviceSettings,
     onSelectDevice: typeof RouterActions.selectDevice,
     gotoExternalWallet: typeof ModalActions.gotoExternalWallet,
-};
+|};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...StateProps, ...DispatchProps |};

src/views/Wallet/components/Title/index.js

@@ -1,9 +1,14 @@
-import React from 'react';
+/* @flow */
+import * as React from 'react';
 import PropTypes from 'prop-types';
 import styled from 'styled-components';
 import { colors } from 'trezor-ui-components';
 import { FONT_SIZE, FONT_WEIGHT } from 'config/variables';
 
+type OwnProps = {|
+    children?: React.Node,
+|};
+
 const Wrapper = styled.div`
     font-size: ${FONT_SIZE.WALLET_TITLE};
     font-weight: ${FONT_WEIGHT.MEDIUM};
@@ -11,7 +16,7 @@ const Wrapper = styled.div`
     padding-bottom: 35px;
 `;
 
-const Title = ({ children }) => <Wrapper>{children}</Wrapper>;
+const Title = ({ children }: OwnProps) => <Wrapper>{children}</Wrapper>;
 
 Title.propTypes = {
     children: PropTypes.node,

src/views/Wallet/components/TopNavigationAccount/index.js

@@ -12,10 +12,15 @@ import { FormattedMessage } from 'react-intl';
 import l10nMessages from './index.messages';
 import Indicator from './components/Indicator';
 
-type Props = {
+type OwnProps = {||};
+
+type StateProps = {|
     router: $ElementType<State, 'router'>,
     selectedAccount: $ElementType<State, 'selectedAccount'>,
-};
+|};
+
+type Props = {| ...OwnProps, ...StateProps |};
+
 type LocalState = {
     wrapper: ?HTMLElement,
 };
@@ -72,7 +77,7 @@ const StyledNavLink = styled(NavLink)`
 `;
 
 class TopNavigationAccount extends React.PureComponent<Props, LocalState> {
-    constructor(props) {
+    constructor(props: Props) {
         super(props);
         this.state = {
             wrapper: null,
@@ -119,10 +124,9 @@ class TopNavigationAccount extends React.PureComponent<Props, LocalState> {
     }
 }
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, _, State, _>(
-    (state: State): Props => ({
+    (state: State): StateProps => ({
         router: state.router,
         selectedAccount: state.selectedAccount,
-    }),
+    })
-    null
 )(TopNavigationAccount);

src/views/Wallet/index.js

@@ -7,11 +7,9 @@ import { connect } from 'react-redux';
 import { Route, withRouter } from 'react-router-dom';
 import { getPattern } from 'support/routes';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
+import type { State, Dispatch } from 'flowtype';
-import type { State } from 'flowtype';
 
-import type { WalletAction } from 'actions/WalletActions';
+import * as WalletActions from 'actions/WalletActions';
-import { toggleSidebar } from 'actions/WalletActions';
 import { bindActionCreators } from 'redux';
 
 import Header from 'components/Header';
@@ -29,18 +27,19 @@ import TopNavigationAccount from './components/TopNavigationAccount';
 import TopNavigationDeviceSettings from './components/TopNavigationDeviceSettings';
 import TopNavigationWalletSettings from './components/TopNavigationWalletSettings';
 
-type StateProps = {
+type StateProps = {|
     wallet: $ElementType<State, 'wallet'>,
-    children?: React.Node,
+|};
-};
 
-type DispatchProps = {
+type DispatchProps = {|
-    toggleSidebar: WalletAction,
+    toggleSidebar: typeof WalletActions.toggleSidebar,
-};
+|};
 
-type OwnProps = {};
+type OwnProps = {|
+    children?: React.Node,
+|};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...StateProps, ...DispatchProps, ...OwnProps |};
 
 const AppWrapper = styled.div`
     position: relative;
@@ -137,26 +136,22 @@ const Wallet = (props: Props) => (
                 <ContextNotifications />
                 <Log />
                 <Body>{props.children}</Body>
-                <Footer />
+                <Footer isLanding={false} />
             </MainContent>
         </WalletWrapper>
         <ModalContainer />
     </AppWrapper>
 );
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     wallet: state.wallet,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
+    toggleSidebar: bindActionCreators(WalletActions.toggleSidebar, dispatch),
-): DispatchProps => ({
-    toggleSidebar: bindActionCreators(toggleSidebar, dispatch),
 });
 
-export default withRouter(
+export default withRouter<Props>(
     connect(
         mapStateToProps,
         mapDispatchToProps

src/views/Wallet/views/Account/Receive/ethereum/Container.js

@@ -2,47 +2,41 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
-import { showAddress } from 'actions/ReceiveActions';
+import * as ReceiveActions from 'actions/ReceiveActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import Receive from './index';
 
-type OwnProps = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
-};
+|};
 
-type StateProps = {
+type StateProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     receive: $ElementType<State, 'receive'>,
     modal: $ElementType<State, 'modal'>,
     wallet: $ElementType<State, 'wallet'>,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
-    showAddress: typeof showAddress,
+    showAddress: typeof ReceiveActions.showAddress,
-};
+|};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     selectedAccount: state.selectedAccount,
     receive: state.receive,
     modal: state.modal,
     wallet: state.wallet,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
+    showAddress: bindActionCreators(ReceiveActions.showAddress, dispatch),
-): DispatchProps => ({
-    showAddress: bindActionCreators(showAddress, dispatch),
 });
 
-export default injectIntl(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
-    connect(
+    mapStateToProps,
-        mapStateToProps,
+    mapDispatchToProps
-        mapDispatchToProps
+)(injectIntl<Props>(Receive));
-    )(Receive)
-);

src/views/Wallet/views/Account/Receive/index.js

@@ -6,17 +6,17 @@ import type { State } from 'flowtype';
 import EthereumTypeReceiveForm from './ethereum/Container';
 import RippleTypeReceiveForm from './ripple/Container';
 
-export type BaseProps = {
+export type BaseProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
-};
+|};
 
 // return container for requested network type
-export default connect(
+export default connect<BaseProps, any, _, _, _, _>(
     (state: State): BaseProps => ({
         selectedAccount: state.selectedAccount,
     }),
     null
-)(props => {
+)((props: BaseProps) => {
     const { network } = props.selectedAccount;
     if (!network) return null;
 

src/views/Wallet/views/Account/Receive/ripple/Container.js

@@ -2,41 +2,37 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
 import { showAddress } from 'actions/ReceiveActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import Receive from './index';
 
-type OwnProps = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
-};
+|};
 
-type StateProps = {
+type StateProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     receive: $ElementType<State, 'receive'>,
     modal: $ElementType<State, 'modal'>,
     wallet: $ElementType<State, 'wallet'>,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     showAddress: typeof showAddress,
-};
+|};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     selectedAccount: state.selectedAccount,
     receive: state.receive,
     modal: state.modal,
     wallet: state.wallet,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     showAddress: bindActionCreators(showAddress, dispatch),
 });
 

src/views/Wallet/views/Account/Send/ethereum/Container.js

@@ -2,36 +2,34 @@
 
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
+import type { IntlShape } from 'react-intl';
 
 import { injectIntl } from 'react-intl';
 import SendFormActions from 'actions/ethereum/SendFormActions';
 import { openQrModal } from 'actions/ModalActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import AccountSend from './index';
 
-type OwnProps = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
-};
+|};
 
-export type StateProps = {
+export type StateProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     sendForm: $ElementType<State, 'sendFormEthereum'>,
     wallet: $ElementType<State, 'wallet'>,
     fiat: $ElementType<State, 'fiat'>,
     localStorage: $ElementType<State, 'localStorage'>,
-};
+|};
 
-export type DispatchProps = {
+export type DispatchProps = {|
     sendFormActions: typeof SendFormActions,
     openQrModal: typeof openQrModal,
-};
+|};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     selectedAccount: state.selectedAccount,
     sendForm: state.sendFormEthereum,
     wallet: state.wallet,
@@ -39,16 +37,12 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     localStorage: state.localStorage,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     sendFormActions: bindActionCreators(SendFormActions, dispatch),
     openQrModal: bindActionCreators(openQrModal, dispatch),
 });
 
-export default injectIntl(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
-    connect(
+    mapStateToProps,
-        mapStateToProps,
+    mapDispatchToProps
-        mapDispatchToProps
+)(injectIntl<OwnProps>(AccountSend));
-    )(AccountSend)
-);

src/views/Wallet/views/Account/Send/ethereum/components/AdvancedForm/index.js

@@ -12,6 +12,8 @@ import {
     colors,
     icons as ICONS,
 } from 'trezor-ui-components';
+import type { IntlShape } from 'react-intl';
+
 import { FONT_SIZE } from 'config/variables';
 
 import l10nCommonMessages from 'views/common.messages';
@@ -19,10 +21,7 @@ import l10nMessages from './index.messages';
 
 import type { Props as BaseProps } from '../../Container';
 
-type Props = BaseProps & {
+type Props = {| ...BaseProps, intl: IntlShape, children: React.Node |};
-    intl: any,
-    children: React.Node,
-};
 
 // TODO: Decide on a small screen width for the whole app
 // and put it inside config/variables.js

src/views/Wallet/views/Account/Send/index.js

@@ -6,17 +6,17 @@ import type { State } from 'flowtype';
 import EthereumTypeSendForm from './ethereum/Container';
 import RippleTypeSendForm from './ripple/Container';
 
-export type BaseProps = {
+export type BaseProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
-};
+|};
 
 // return container for requested network type
-export default connect(
+export default connect<BaseProps, any, _, _, _, _>(
     (state: State): BaseProps => ({
         selectedAccount: state.selectedAccount,
     }),
     null
-)(props => {
+)((props: BaseProps) => {
     const { network } = props.selectedAccount;
     if (!network) return null;
 

src/views/Wallet/views/Account/Send/ripple/Container.js

@@ -3,35 +3,33 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
 import SendFormActions from 'actions/ripple/SendFormActions';
 import { openQrModal } from 'actions/ModalActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import AccountSend from './index';
 
-type OwnProps = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
-};
+|};
 
-export type StateProps = {
+export type StateProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     sendForm: $ElementType<State, 'sendFormRipple'>,
     wallet: $ElementType<State, 'wallet'>,
     fiat: $ElementType<State, 'fiat'>,
     localStorage: $ElementType<State, 'localStorage'>,
-};
+|};
 
-export type DispatchProps = {
+export type DispatchProps = {|
     sendFormActions: typeof SendFormActions,
     openQrModal: typeof openQrModal,
-};
+|};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     selectedAccount: state.selectedAccount,
     sendForm: state.sendFormRipple,
     wallet: state.wallet,
@@ -39,15 +37,13 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     localStorage: state.localStorage,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     sendFormActions: bindActionCreators(SendFormActions, dispatch),
     openQrModal: bindActionCreators(openQrModal, dispatch),
 });
 
 export default injectIntl(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
         mapStateToProps,
         mapDispatchToProps
     )(AccountSend)

src/views/Wallet/views/Account/Send/ripple/components/AdvancedForm/index.js

@@ -11,9 +11,7 @@ import l10nMessages from './index.messages';
 
 import type { Props as BaseProps } from '../../Container';
 
-type Props = BaseProps & {
+type Props = {| ...BaseProps, children: React.Node |};
-    children: React.Node,
-};
 
 // TODO: Decide on a small screen width for the whole app
 // and put it inside config/variables.js

src/views/Wallet/views/Account/SignVerify/Container.js

@@ -3,49 +3,45 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
 import SignVerifyActions from 'actions/SignVerifyActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import Component from './index';
 
-type OwnProps = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
-};
+|};
 
 export type Error = {
     inputName: string,
     message: ?string,
 };
 
-export type StateProps = {
+export type StateProps = {|
     wallet: $ElementType<State, 'wallet'>,
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     signVerify: $ElementType<State, 'signVerify'>,
-};
+|};
 
-export type DispatchProps = {
+export type DispatchProps = {|
     signVerifyActions: typeof SignVerifyActions,
-};
+|};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     wallet: state.wallet,
     selectedAccount: state.selectedAccount,
     signVerify: state.signVerify,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     signVerifyActions: bindActionCreators(SignVerifyActions, dispatch),
 });
 
 export default injectIntl(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
         mapStateToProps,
         mapDispatchToProps
     )(Component)

src/views/Wallet/views/Account/Summary/ethereum/Container.js

@@ -2,37 +2,35 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import * as TokenActions from 'actions/TokenActions';
 
 import type { State, Dispatch } from 'flowtype';
 import Summary from './index';
 
-type OwnProps = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
-};
+|};
 
-type StateProps = {
+type StateProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     summary: $ElementType<State, 'summary'>,
     wallet: $ElementType<State, 'wallet'>,
     tokens: $ElementType<State, 'tokens'>,
     fiat: $ElementType<State, 'fiat'>,
     localStorage: $ElementType<State, 'localStorage'>,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     addToken: typeof TokenActions.add,
     loadTokens: typeof TokenActions.load,
     removeToken: typeof TokenActions.remove,
-};
+|};
 
-export type Props = OwnProps & StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     selectedAccount: state.selectedAccount,
     summary: state.summary,
     wallet: state.wallet,
@@ -41,16 +39,14 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     localStorage: state.localStorage,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     addToken: bindActionCreators(TokenActions.add, dispatch),
     loadTokens: bindActionCreators(TokenActions.load, dispatch),
     removeToken: bindActionCreators(TokenActions.remove, dispatch),
 });
 
 export default injectIntl(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
         mapStateToProps,
         mapDispatchToProps
     )(Summary)

src/views/Wallet/views/Account/Summary/index.js

@@ -6,17 +6,16 @@ import type { State } from 'flowtype';
 import EthereumTypeSummary from './ethereum/Container';
 import RippleTypeSummary from './ripple/Container';
 
-type WrapperProps = {
+type WrapperProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
-};
+|};
 
 // return container for requested network type
-export default connect(
+export default connect<WrapperProps, any, _, _, _, _>(
     (state: State): WrapperProps => ({
         selectedAccount: state.selectedAccount,
-    }),
+    })
-    null
+)((props: WrapperProps) => {
-)(props => {
     const { network } = props.selectedAccount;
     if (!network) return null;
 

src/views/Wallet/views/Account/Summary/ripple/Container.js

@@ -2,34 +2,31 @@
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import * as TokenActions from 'actions/TokenActions';
 
 import type { State, Dispatch } from 'flowtype';
 import Summary from './index';
 
-type OwnProps = {};
+type OwnProps = {||};
 
-type StateProps = {
+type StateProps = {|
     selectedAccount: $ElementType<State, 'selectedAccount'>,
     summary: $ElementType<State, 'summary'>,
     wallet: $ElementType<State, 'wallet'>,
     tokens: $ElementType<State, 'tokens'>,
     fiat: $ElementType<State, 'fiat'>,
     localStorage: $ElementType<State, 'localStorage'>,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     addToken: typeof TokenActions.add,
     loadTokens: typeof TokenActions.load,
     removeToken: typeof TokenActions.remove,
-};
+|};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     selectedAccount: state.selectedAccount,
     summary: state.summary,
     wallet: state.wallet,
@@ -38,15 +35,13 @@ const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
     localStorage: state.localStorage,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     addToken: bindActionCreators(TokenActions.add, dispatch),
     loadTokens: bindActionCreators(TokenActions.load, dispatch),
     removeToken: bindActionCreators(TokenActions.remove, dispatch),
 });
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
     mapStateToProps,
     mapDispatchToProps
 )(Summary);

src/views/Wallet/views/Acquire/index.js

@@ -4,17 +4,26 @@ import styled from 'styled-components';
 import { bindActionCreators } from 'redux';
 import { connect } from 'react-redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
 import { colors, Notification } from 'trezor-ui-components';
 import * as TrezorConnectActions from 'actions/TrezorConnectActions';
 import type { State, Dispatch } from 'flowtype';
 import l10nMessages from './index.messages';
 
-type Props = {
+type OwnProps = {|
-    intl: any,
+    intl: IntlShape,
+|};
+
+type StateProps = {|
     acquiring: boolean,
+|};
+
+type DispatchProps = {|
     acquireDevice: typeof TrezorConnectActions.acquire,
-};
+|};
+
+type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
 const Wrapper = styled.div`
     display: flex;
@@ -43,12 +52,12 @@ const Acquire = (props: Props) => (
     </Wrapper>
 );
 
-export default injectIntl(
+export default injectIntl<OwnProps>(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
-        (state: State) => ({
+        (state: State): StateProps => ({
             acquiring: state.connect.acquiringDevice,
         }),
-        (dispatch: Dispatch) => ({
+        (dispatch: Dispatch): DispatchProps => ({
             acquireDevice: bindActionCreators(TrezorConnectActions.acquire, dispatch),
         })
     )(Acquire)

src/views/Wallet/views/Bootloader/index.js

@@ -1,7 +1,7 @@
+/* @flow */
 import React from 'react';
 import styled from 'styled-components';
 import { H4, P } from 'trezor-ui-components';
-import { connect } from 'react-redux';
 import { FormattedMessage } from 'react-intl';
 
 import l10nMessages from './index.messages';
@@ -42,7 +42,4 @@ const Bootloader = () => (
     </Wrapper>
 );
 
-export default connect(
+export default Bootloader;
-    null,
-    null
-)(Bootloader);

src/views/Wallet/views/Dashboard/Container.js

@@ -1,26 +1,20 @@
 /* @flow */
 import { connect } from 'react-redux';
-import type { MapStateToProps } from 'react-redux';
+import type { State, Dispatch } from 'flowtype';
-import type { State } from 'flowtype';
 import Dashboard from './index';
 
-type OwnProps = {};
+type OwnProps = {||};
 
-type StateProps = {
+type StateProps = {|
     localStorage: $ElementType<State, 'localStorage'>,
     wallet: $ElementType<State, 'wallet'>,
-};
+|};
 
-export type Props = StateProps;
+export type Props = {| ...StateProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     localStorage: state.localStorage,
     wallet: state.wallet,
 });
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, _, State, Dispatch>(mapStateToProps)(Dashboard);
-    mapStateToProps,
-    null
-)(Dashboard);

src/views/Wallet/views/DeviceSettings/index.js

@@ -4,7 +4,6 @@ import styled from 'styled-components';
 import { H4, Icon, Button, P, Link, colors, icons as ICONS } from 'trezor-ui-components';
 import { getOldWalletUrl } from 'utils/url';
 import Content from 'views/Wallet/components/Content';
-import { connect } from 'react-redux';
 
 import type { TrezorDevice } from 'flowtype';
 
@@ -51,7 +50,4 @@ const DeviceSettings = (props: Props) => (
     </Content>
 );
 
-export default connect(
+export default DeviceSettings;
-    null,
-    null
-)(DeviceSettings);

src/views/Wallet/views/FirmwareUpdate/index.js

@@ -17,9 +17,17 @@ import l10nCommonMessages from 'views/common.messages';
 import type { TrezorDevice, State, Dispatch } from 'flowtype';
 import l10nMessages from './index.messages';
 
-type Props = {
+type OwnProps = {||};
+
+type StateProps = {|
     device: ?TrezorDevice,
-};
+|};
+
+type DispatchProps = {|
+    cancel: typeof RouterActions.selectFirstAvailableDevice,
+|};
+
+type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
 const Wrapper = styled.section`
     display: flex;
@@ -180,11 +188,11 @@ const FirmwareUpdate = (props: Props) => (
     </Wrapper>
 );
 
-export default connect(
+export default connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
-    (state: State) => ({
+    (state: State): StateProps => ({
         device: state.wallet.selectedDevice,
     }),
-    (dispatch: Dispatch) => ({
+    (dispatch: Dispatch): DispatchProps => ({
         cancel: bindActionCreators(RouterActions.selectFirstAvailableDevice, dispatch),
     })
 )(FirmwareUpdate);

src/views/Wallet/views/Initialize/index.js

@@ -3,7 +3,6 @@ import styled from 'styled-components';
 import { H4, Button, P } from 'trezor-ui-components';
 import { getOldWalletUrl } from 'utils/url';
 import React from 'react';
-import { connect } from 'react-redux';
 import { FormattedMessage } from 'react-intl';
 
 import l10nCommonMessages from 'views/common.messages';
@@ -54,7 +53,4 @@ const Initialize = (props: Props) => (
     </Wrapper>
 );
 
-export default connect(
+export default Initialize;
-    null,
-    null
-)(Initialize);

src/views/Wallet/views/Seedless/index.js

@@ -1,7 +1,6 @@
 import styled from 'styled-components';
 import { H4, P } from 'trezor-ui-components';
 import React from 'react';
-import { connect } from 'react-redux';
 import { FormattedMessage } from 'react-intl';
 
 import l10nMessages from './index.messages';
@@ -37,7 +36,4 @@ const Seedless = () => (
     </Wrapper>
 );
 
-export default connect(
+export default Seedless;
-    null,
-    null
-)(Seedless);

src/views/Wallet/views/UnreadableDevice/index.js

@@ -4,11 +4,12 @@ import React from 'react';
 import styled from 'styled-components';
 import { Notification } from 'trezor-ui-components';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 import l10nMessages from './index.messages';
 
 const Wrapper = styled.div``;
 
-const UnreadableDevice = ({ intl }: { intl: any }) => (
+const UnreadableDevice = ({ intl }: { intl: IntlShape }) => (
     <Wrapper>
         <Notification
             title={intl.formatMessage(l10nMessages.TR_UNREADABLE_DEVICE)}

src/views/Wallet/views/WalletSettings/Container.js

@@ -2,44 +2,42 @@
 import { connect } from 'react-redux';
 import { bindActionCreators } from 'redux';
 import { injectIntl } from 'react-intl';
+import type { IntlShape } from 'react-intl';
 
 import * as WalletActions from 'actions/WalletActions';
-import type { MapStateToProps, MapDispatchToProps } from 'react-redux';
 import type { State, Dispatch } from 'flowtype';
 import WalletSettings from './index';
 
-type OwnProps = {};
+type OwnProps = {|
+    intl: IntlShape,
+|};
 
-type StateProps = {
+type StateProps = {|
     wallet: $ElementType<State, 'wallet'>,
     fiat: $ElementType<State, 'fiat'>,
     localStorage: $ElementType<State, 'localStorage'>,
-};
+|};
 
-type DispatchProps = {
+type DispatchProps = {|
     setLocalCurrency: typeof WalletActions.setLocalCurrency,
     setHideBalance: typeof WalletActions.setHideBalance,
-};
+|};
 
-export type Props = StateProps & DispatchProps;
+export type Props = {| ...OwnProps, ...StateProps, ...DispatchProps |};
 
-const mapStateToProps: MapStateToProps<State, OwnProps, StateProps> = (
+const mapStateToProps = (state: State): StateProps => ({
-    state: State
-): StateProps => ({
     wallet: state.wallet,
     fiat: state.fiat,
     localStorage: state.localStorage,
 });
 
-const mapDispatchToProps: MapDispatchToProps<Dispatch, OwnProps, DispatchProps> = (
+const mapDispatchToProps = (dispatch: Dispatch): DispatchProps => ({
-    dispatch: Dispatch
-): DispatchProps => ({
     setLocalCurrency: bindActionCreators(WalletActions.setLocalCurrency, dispatch),
     setHideBalance: bindActionCreators(WalletActions.setHideBalance, dispatch),
 });
 
-export default injectIntl(
+export default injectIntl<OwnProps>(
-    connect(
+    connect<Props, OwnProps, StateProps, DispatchProps, State, Dispatch>(
         mapStateToProps,
         mapDispatchToProps
     )(WalletSettings)

yarn.lock

@@ -4984,9 +4984,10 @@ flatted@^2.0.0:
   resolved "https://registry.yarnpkg.com/flatted/-/flatted-2.0.0.tgz#55122b6536ea496b4b44893ee2608141d10d9916"
   integrity sha512-R+H8IZclI8AAkSBRQJLVOsxwAoHd6WC40b4QTNWIjzAa6BXOBfQcM587MXDTVPeYaopFNWHUFLx7eNmHDSxMWg==
 
-flow-bin@0.75.0:
+flow-bin@0.90:
-  version "0.75.0"
+  version "0.90.0"
-  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.75.0.tgz#b96d1ee99d3b446a3226be66b4013224ce9df260"
+  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.90.0.tgz#733b6d29a8c8a22b9a5d273611d9a8402faf3445"
+  integrity sha512-/syDchjhLLL7nELK1ggyWJifGXuMCTz74kvkjR1t9DcmasMrilLl9qAAotsACcNb98etEEJpsCrvP7WL64kadw==
 
 flush-write-stream@^1.0.0:
   version "1.0.2"