diff --git a/components/Channels/SortButton.tsx b/components/Channels/SortButton.tsx
new file mode 100644
index 000000000..dd8e70cb3
--- /dev/null
+++ b/components/Channels/SortButton.tsx
@@ -0,0 +1,97 @@
+import * as React from 'react';
+import { ActionSheetIOS, Platform, View } from 'react-native';
+import { Picker } from '@react-native-picker/picker';
+
+import Button from '../../components/Button';
+import { themeColor } from '../../utils/ThemeUtils';
+import { localeString } from '../../utils/LocaleUtils';
+
+interface SortButtonProps {
+    onValueChange: (value: any) => void;
+    values: Array<any>;
+}
+
+export default class SortButton extends React.Component<SortButtonProps, {}> {
+    render() {
+        const { onValueChange, values } = this.props;
+
+        // TODO for some reason it will not responsd to item 0 so a cancel item
+        // is placed here
+        const pickerValuesAndroid: Array<any> = [
+            <Picker.Item
+                key={'cancel'}
+                label={localeString('general.cancel')}
+            />
+        ];
+        const pickerValuesIOS: Array<string> = [localeString('general.cancel')];
+        values.forEach((value: { key: string; value: any }) => {
+            pickerValuesAndroid.push(
+                <Picker.Item
+                    key={value.key}
+                    label={value.key}
+                    value={value.value}
+                />
+            );
+            pickerValuesIOS.push(value.key);
+        });
+
+        return (
+            <React.Fragment>
+                {Platform.OS === 'android' && (
+                    <View
+                        style={{
+                            height: 50,
+                            overflow: 'hidden',
+                            borderRadius: 16
+                        }}
+                    >
+                        <Picker
+                            onValueChange={(itemValue: any) =>
+                                onValueChange(itemValue)
+                            }
+                            style={{
+                                marginTop: -2,
+                                width: 48,
+                                color: themeColor('text'),
+                                backgroundColor: themeColor('secondary')
+                            }}
+                            dropdownIconColor={themeColor('text')}
+                        >
+                            {pickerValuesAndroid}
+                        </Picker>
+                    </View>
+                )}
+
+                {Platform.OS === 'ios' && (
+                    <View>
+                        <Button
+                            title=""
+                            icon={{
+                                name: 'sort',
+                                size: 25
+                            }}
+                            adaptiveWidth
+                            buttonStyle={{ width: 50 }}
+                            quinary
+                            onPress={() =>
+                                ActionSheetIOS.showActionSheetWithOptions(
+                                    {
+                                        options: pickerValuesIOS,
+                                        cancelButtonIndex: 0
+                                    },
+                                    (buttonIndex) => {
+                                        if (buttonIndex) {
+                                            onValueChange(
+                                                values[buttonIndex - 1].value
+                                            );
+                                        }
+                                    }
+                                )
+                            }
+                        />
+                    </View>
+                )}
+            </React.Fragment>
+        );
+    }
+}
diff --git a/locales/en.json b/locales/en.json
index b8f9c82b3..4c596ed0b 100644
--- a/locales/en.json
+++ b/locales/en.json
@@ -272,6 +272,12 @@
     "views.Channel.closed": "Closed",
     "views.Channel.pendingClose": "Pending close",
     "views.Channel.pendingOpen": "Pending open",
+    "views.Channel.SortButton.largestFirst": "largest first",
+    "views.Channel.SortButton.smallestFirst": "smallest first",
+    "views.Channel.SortButton.ascending": "ascending",
+    "views.Channel.SortButton.descending": "descending",
+    "views.Channel.channelId": "Channel ID",
+    "views.Channel.displayName": "Display name",
     "views.UTXOs.CoinControl.noUTXOs": "No UTXOs available",
     "views.EditFee.mainText": "Edit network fee",
     "views.EditFee.fastestFee": "Fastest fee",
diff --git a/models/Channel.ts b/models/Channel.ts
index a0874520e..31663b60a 100644
--- a/models/Channel.ts
+++ b/models/Channel.ts
@@ -1,3 +1,4 @@
+import BigNumber from 'bignumber.js';
 import { observable, computed } from 'mobx';
 import BaseModel from './BaseModel';
 import { localeString } from './../utils/LocaleUtils';
@@ -42,19 +43,19 @@ export default class Channel extends BaseModel {
     // pending
     remote_node_pub: string;
 
+    // enrichments
+    displayName?: string;
+
     @computed
     public get isActive(): boolean {
         return this.active || this.state === 'CHANNELD_NORMAL';
     }
 
     @computed
-    public get remoteBalance(): string {
-        return this.msatoshi_total
-            ? (
-                  (Number(this.msatoshi_total) - Number(this.msatoshi_to_us)) /
-                  1000
-              ).toString()
-            : this.remote_balance || '0';
+    public get channelCapacity(): string {
+        return new BigNumber(this.localBalance)
+            .plus(this.remoteBalance)
+            .toString();
     }
 
     @computed
@@ -64,6 +65,16 @@ export default class Channel extends BaseModel {
             : this.local_balance || '0';
     }
 
+    @computed
+    public get remoteBalance(): string {
+        return this.msatoshi_total
+            ? (
+                  (Number(this.msatoshi_total) - Number(this.msatoshi_to_us)) /
+                  1000
+              ).toString()
+            : this.remote_balance || '0';
+    }
+
     @computed
     public get channelId(): string {
         return (
diff --git a/stores/ChannelsStore.ts b/stores/ChannelsStore.ts
index 01aa43804..687383ab8 100644
--- a/stores/ChannelsStore.ts
+++ b/stores/ChannelsStore.ts
@@ -50,6 +50,20 @@ export default class ChannelsStore {
     @observable public totalOffline = 0;
     @observable public chanInfo: ChannelInfoIndex = {};
     @observable public channelsType = ChannelsType.Open;
+    // enriched
+    @observable public enrichedChannels: Array<Channel> = [];
+    @observable public enrichedPendingChannels: Array<Channel> = [];
+    @observable public enrichedClosedChannels: Array<Channel> = [];
+    // search and sort
+    @observable public search: string = '';
+    @observable public filteredChannels: Array<Channel> = [];
+    @observable public filteredPendingChannels: Array<Channel> = [];
+    @observable public filteredClosedChannels: Array<Channel> = [];
+    @observable public sort = {
+        param: 'channelCapacity',
+        dir: 'DESC',
+        type: 'numeric'
+    };
 
     settingsStore: SettingsStore;
 
@@ -68,33 +82,36 @@ export default class ChannelsStore {
 
         reaction(
             () => this.channels,
-            () => {
+            async () => {
                 if (this.channels) {
-                    this.channels.forEach((channel: any) =>
-                        this.enrichChannel(channel)
+                    this.enrichedChannels = await this.enrichChannels(
+                        this.channels
                     );
+                    this.filterChannels();
                 }
             }
         );
 
         reaction(
             () => this.pendingChannels,
-            () => {
+            async () => {
                 if (this.pendingChannels) {
-                    this.pendingChannels.forEach((channel: any) =>
-                        this.enrichChannel(channel)
+                    this.enrichedPendingChannels = await this.enrichChannels(
+                        this.pendingChannels
                     );
+                    this.filterPendingChannels();
                 }
             }
         );
 
         reaction(
             () => this.closedChannels,
-            () => {
+            async () => {
                 if (this.closedChannels) {
-                    this.closedChannels.forEach((channel: any) =>
-                        this.enrichChannel(channel)
+                    this.enrichedClosedChannels = await this.enrichChannels(
+                        this.closedChannels
                     );
+                    this.filterClosedChannels();
                 }
             }
         );
@@ -129,6 +146,68 @@ export default class ChannelsStore {
         this.channelsType = ChannelsType.Open;
     };
 
+    @action
+    setSearch = (query: string) => {
+        this.search = query;
+        this.filterChannels();
+        this.filterPendingChannels();
+        this.filterClosedChannels();
+    };
+
+    @action
+    setSort = (value: any) => {
+        this.sort = value;
+        this.filterChannels();
+        this.filterPendingChannels();
+        this.filterClosedChannels();
+    };
+
+    @action
+    filter = (channels: Array<Channel>) => {
+        const query = this.search;
+        const filtered = channels.filter(
+            (channel: Channel) =>
+                channel.alias?.includes(query) ||
+                channel.alias?.toLocaleLowerCase().includes(query) ||
+                channel.remotePubkey.includes(query) ||
+                channel.remotePubkey.toLowerCase().includes(query) ||
+                channel.channelId.includes(query) ||
+                channel.channelId.toLowerCase().includes(query)
+        );
+
+        const sorted = filtered.sort((a: any, b: any) => {
+            if (this.sort.type === 'numeric') {
+                return Number(a[this.sort.param]) < Number(b[this.sort.param])
+                    ? 1
+                    : -1;
+            } else {
+                return a[this.sort.param].toLowerCase() <
+                    b[this.sort.param].toLowerCase()
+                    ? 1
+                    : -1;
+            }
+        });
+
+        return this.sort.dir === 'DESC' ? sorted : sorted.reverse();
+    };
+
+    @action
+    filterChannels = () => {
+        this.filteredChannels = this.filter(this.enrichedChannels);
+    };
+
+    @action
+    filterPendingChannels = () => {
+        this.filteredPendingChannels = this.filter(
+            this.enrichedPendingChannels
+        );
+    };
+
+    @action
+    filterClosedChannels = () => {
+        this.filteredClosedChannels = this.filter(this.enrichedClosedChannels);
+    };
+
     @action
     getNodeInfo = (pubkey: string) =>
         BackendUtils.getNodeInfo([pubkey]).then((data: any) => {
@@ -136,25 +215,35 @@ export default class ChannelsStore {
         });
 
     @action
-    enrichChannel = (channel: any) => {
-        if (!channel.remotePubkey) return;
-        if (
-            this.settingsStore.implementation !== 'c-lightning-REST' &&
-            !this.nodes[channel.remotePubkey]
-        ) {
-            this.getNodeInfo(channel.remotePubkey)
-                .then((nodeInfo: any) => {
-                    if (!nodeInfo) return;
-                    this.nodes[channel.remotePubkey] = nodeInfo;
-                    this.aliasesById[channel.channelId] = nodeInfo.alias;
-                })
-                .catch((err: any) => {
-                    console.log(
-                        `Couldn't find node alias for ${channel.remotePubkey}`,
-                        err
-                    );
-                });
-        }
+    enrichChannels = (channels: Array<Channel>) => {
+        this.loading = true;
+        channels.forEach(async (channel: Channel) => {
+            if (!channel.remotePubkey) return;
+            if (
+                this.settingsStore.implementation !== 'c-lightning-REST' &&
+                !this.nodes[channel.remotePubkey]
+            ) {
+                await this.getNodeInfo(channel.remotePubkey)
+                    .then((nodeInfo: any) => {
+                        if (!nodeInfo) return;
+                        this.nodes[channel.remotePubkey] = nodeInfo;
+                        this.aliasesById[channel.channelId] = nodeInfo.alias;
+                    })
+                    .catch((err: any) => {
+                        console.log(
+                            `Couldn't find node alias for ${channel.remotePubkey}`,
+                            err
+                        );
+                    });
+            }
+            if (!channel.alias && this.aliasesById[channel.channelId]) {
+                channel.alias = this.aliasesById[channel.channelId];
+            }
+            channel.displayName =
+                channel.alias || channel.remotePubkey || channel.channelId;
+        });
+        this.loading = false;
+        return channels;
     };
 
     getChannelsError = () => {
@@ -396,9 +485,8 @@ export default class ChannelsStore {
                         };
 
                         BackendUtils.openChannel(openChanRequest)
-                            .then((data: any) => {
-                                console.log('chan2 data');
-                                console.log(data);
+                            .then(() => {
+                                // TODO
                             })
                             .catch((error: any) => {
                                 this.errorMsgChannel = error.toString();
diff --git a/views/Channels/Channel.tsx b/views/Channels/Channel.tsx
index 86b5470be..85b868dca 100644
--- a/views/Channels/Channel.tsx
+++ b/views/Channels/Channel.tsx
@@ -110,10 +110,9 @@ export default class ChannelView extends React.Component<
     };
 
     render() {
-        const { navigation, ChannelsStore, SettingsStore } = this.props;
+        const { navigation, SettingsStore } = this.props;
         const { channel, confirmCloseChannel, satPerByte, forceCloseChannel } =
             this.state;
-        const { nodes } = ChannelsStore;
         const { settings, implementation } = SettingsStore;
         const { privacy } = settings;
         const lurkerMode = privacy && privacy.lurkerMode;
@@ -132,12 +131,12 @@ export default class ChannelView extends React.Component<
             total_satoshis_sent,
             remotePubkey,
             capacity,
-            alias,
             channelId,
             initiator,
             alias_scids,
             local_chan_reserve_sat,
             remote_chan_reserve_sat,
+            displayName,
             // closed
             closeHeight,
             closeType,
@@ -164,12 +163,7 @@ export default class ChannelView extends React.Component<
         );
         const bumpable: boolean = pendingOpen;
 
-        const peerName =
-            (nodes[remotePubkey] && nodes[remotePubkey].alias) ||
-            alias ||
-            channelId;
-
-        const peerDisplay = PrivacyUtils.sensitiveValue(peerName, 8);
+        const peerDisplay = PrivacyUtils.sensitiveValue(displayName, 8);
 
         const BackButton = () => (
             <Icon
diff --git a/views/Channels/ChannelsPane.tsx b/views/Channels/ChannelsPane.tsx
index 5539dd829..0f34abb85 100644
--- a/views/Channels/ChannelsPane.tsx
+++ b/views/Channels/ChannelsPane.tsx
@@ -1,21 +1,93 @@
 import * as React from 'react';
-import { FlatList, View, TouchableHighlight } from 'react-native';
-
+import { Dimensions, FlatList, View, TouchableHighlight } from 'react-native';
+import { SearchBar } from 'react-native-elements';
 import { inject, observer } from 'mobx-react';
+import { duration } from 'moment';
 
 import { ChannelsHeader } from '../../components/Channels/ChannelsHeader';
 import { ChannelItem } from '../../components/Channels/ChannelItem';
+import SortButton from '../../components/Channels/SortButton';
+
 import LoadingIndicator from '../../components/LoadingIndicator';
 import WalletHeader from '../../components/WalletHeader';
-
-import { localeString } from '../../utils/LocaleUtils';
+import { Row } from '../../components/layout/Row';
 import { Spacer } from '../../components/layout/Spacer';
 
 import ChannelsStore, { ChannelsType } from '../../stores/ChannelsStore';
 import SettingsStore from '../../stores/SettingsStore';
 
-import { duration } from 'moment';
 import BackendUtils from '../../utils/BackendUtils';
+import { localeString } from '../../utils/LocaleUtils';
+import { themeColor } from '../../utils/ThemeUtils';
+
+const CHANNELS_SORT_KEYS = [
+    {
+        key: `${localeString('views.Channel.capacity')} (${localeString(
+            'views.Channel.SortButton.largestFirst'
+        )})`,
+        value: {
+            param: 'channelCapacity',
+            dir: 'DESC',
+            type: 'numeric'
+        }
+    },
+    {
+        key: `${localeString('views.Channel.capacity')} (${localeString(
+            'views.Channel.SortButton.smallestFirst'
+        )})`,
+        value: { param: 'channelCapacity', dir: 'ASC', type: 'numeric' }
+    },
+
+    {
+        key: `${localeString('views.Channel.inbound')} ${localeString(
+            'views.Channel.capacity'
+        )} (${localeString('views.Channel.SortButton.largestFirst')})`,
+        value: { param: 'remoteBalance', dir: 'DESC', type: 'numeric' }
+    },
+    {
+        key: `${localeString('views.Channel.inbound')} ${localeString(
+            'views.Channel.capacity'
+        )} (${localeString('views.Channel.SortButton.smallestFirst')})`,
+        value: { param: 'remoteBalance', dir: 'ASC', type: 'numeric' }
+    },
+
+    {
+        key: `${localeString('views.Channel.outbound')} ${localeString(
+            'views.Channel.capacity'
+        )} (${localeString('views.Channel.SortButton.largestFirst')})`,
+        value: { param: 'localBalance', dir: 'DESC', type: 'numeric' }
+    },
+    {
+        key: `${localeString('views.Channel.outbound')} ${localeString(
+            'views.Channel.capacity'
+        )} (${localeString('views.Channel.SortButton.smallestFirst')})`,
+        value: { param: 'localBalance', dir: 'ASC', type: 'numeric' }
+    },
+    {
+        key: `${localeString('views.Channel.displayName')} (${localeString(
+            'views.Channel.SortButton.ascending'
+        )})`,
+        value: { param: 'displayName', dir: 'ASC', type: 'alphanumeric' }
+    },
+    {
+        key: `${localeString('views.Channel.displayName')} (${localeString(
+            'views.Channel.SortButton.descending'
+        )})`,
+        value: { param: 'displayName', dir: 'DESC', type: 'alphanumeric' }
+    }
+    // {
+    //     key: `${localeString('views.Channel.channelId')} (${localeString(
+    //         'views.Channel.SortButton.ascending'
+    //     )})`,
+    //     value: { param: 'channelId', dir: 'ASC', type: 'alphanumeric' }
+    // },
+    // {
+    //     key: `${localeString('views.Channel.channelId')} (${localeString(
+    //         'views.Channel.SortButton.descending'
+    //     )})`,
+    //     value: { param: 'channelId', dir: 'DESC', type: 'alphanumeric' }
+    // }
+];
 
 // TODO: does this belong in the model? Or can it be computed from the model?
 export enum Status {
@@ -38,12 +110,8 @@ interface ChannelsProps {
 export default class ChannelsPane extends React.PureComponent<ChannelsProps> {
     renderItem = ({ item }) => {
         const { ChannelsStore, navigation } = this.props;
-        const { nodes, largestChannelSats, channelsType } = ChannelsStore;
-        const displayName =
-            item.alias ||
-            (nodes[item.remotePubkey] && nodes[item.remotePubkey].alias) ||
-            item.remotePubkey ||
-            item.channelId;
+        const { largestChannelSats, channelsType } = ChannelsStore;
+        const displayName = item.alias || item.remotePubkey || item.channelId;
 
         const getStatus = () => {
             if (item.isActive) {
@@ -123,18 +191,26 @@ export default class ChannelsPane extends React.PureComponent<ChannelsProps> {
         ChannelsStore.setChannelsType(newType);
     };
 
+    updateSearch = (value: string) => {
+        // const result = CURRENCY_KEYS.filter((item: any) =>
+        //     item.key.includes(value)
+        // );
+        this.props.ChannelsStore.setSearch(value);
+    };
+
     render() {
         const { ChannelsStore, SettingsStore, navigation } = this.props;
-        const { channelsType } = ChannelsStore;
+        const { channelsType, search } = ChannelsStore;
         const {
             loading,
             getChannels,
             totalInbound,
             totalOutbound,
             totalOffline,
-            channels,
-            pendingChannels,
-            closedChannels
+            filteredChannels,
+            filteredPendingChannels,
+            filteredClosedChannels,
+            setSort
         } = ChannelsStore;
 
         let headerString;
@@ -143,23 +219,25 @@ export default class ChannelsPane extends React.PureComponent<ChannelsProps> {
             case ChannelsType.Open:
                 headerString = `${localeString(
                     'views.Wallet.Wallet.channels'
-                )} (${channels.length})`;
-                channelsData = channels;
+                )} (${filteredChannels.length})`;
+                channelsData = filteredChannels;
                 break;
             case ChannelsType.Pending:
                 headerString = `${localeString(
                     'views.Wallet.Wallet.pendingChannels'
-                )} (${pendingChannels.length})`;
-                channelsData = pendingChannels;
+                )} (${filteredPendingChannels.length})`;
+                channelsData = filteredPendingChannels;
                 break;
             case ChannelsType.Closed:
                 headerString = `${localeString(
                     'views.Wallet.Wallet.closedChannels'
-                )} (${closedChannels.length})`;
-                channelsData = closedChannels;
+                )} (${filteredClosedChannels.length})`;
+                channelsData = filteredClosedChannels;
                 break;
         }
 
+        const windowWidth = Dimensions.get('window').width;
+
         return (
             <View style={{ flex: 1 }}>
                 <WalletHeader
@@ -178,6 +256,35 @@ export default class ChannelsPane extends React.PureComponent<ChannelsProps> {
                     totalOutbound={totalOutbound}
                     totalOffline={totalOffline}
                 />
+                <Row>
+                    <SearchBar
+                        placeholder={localeString('general.search')}
+                        onChangeText={this.updateSearch}
+                        value={search}
+                        inputStyle={{
+                            color: themeColor('text'),
+                            fontFamily: 'Lato-Regular'
+                        }}
+                        placeholderTextColor={themeColor('secondaryText')}
+                        containerStyle={{
+                            backgroundColor: null,
+                            borderTopWidth: 0,
+                            borderBottomWidth: 0,
+                            width: windowWidth - 55
+                        }}
+                        inputContainerStyle={{
+                            borderRadius: 15,
+                            backgroundColor: themeColor('secondary')
+                        }}
+                        autoCapitalize="none"
+                    />
+                    <SortButton
+                        onValueChange={(value: any) => {
+                            setSort(value);
+                        }}
+                        values={CHANNELS_SORT_KEYS}
+                    />
+                </Row>
                 {loading ? (
                     <View style={{ top: 40 }}>
                         <LoadingIndicator />