sync-language

pass channel_id on list update
Merge pull request #431 from saltrafael/list-thumb
2021-10-08 16:12:32 -04:00 · 2021-09-13 12:05:57 -04:00 · 2021-09-13 11:24:58 -04:00 · 2021-09-13 07:38:21 -03:00 · 2021-09-11 13:18:41 -04:00 · 2021-09-06 13:17:07 -04:00
32 changed files with 3998 additions and 526 deletions
--- a/dist/bundle.es.js
+++ b/dist/bundle.es.js
--- a/dist/flow-typed/Claim.js
+++ b/dist/flow-typed/Claim.js
@ -1,11 +1,15 @@
 // @flow

-declare type Claim = StreamClaim | ChannelClaim;
+declare type Claim = StreamClaim | ChannelClaim | CollectionClaim;

 declare type ChannelClaim = GenericClaim & {
  value: ChannelMetadata,
 };

+declare type CollectionClaim = GenericClaim & {
+  value: CollectionMetadata,
+};
+
 declare type StreamClaim = GenericClaim & {
  value: StreamMetadata,
 };
@ -30,7 +34,7 @@ declare type GenericClaim = {
  short_url: string, // permanent_url with short id, no channel
  txid: string, // unique tx id
  type: 'claim' | 'update' | 'support',
-  value_type: 'stream' | 'channel',
+  value_type: 'stream' | 'channel' | 'collection',
  signing_channel?: ChannelClaim,
  reposted_claim?: GenericClaim,
  repost_channel_url?: string,
@ -74,6 +78,10 @@ declare type ChannelMetadata = GenericMetadata & {
  featured?: Array<string>,
 };

+declare type CollectionMetadata = GenericMetadata & {
+  claims: Array<string>,
+}
+
 declare type StreamMetadata = GenericMetadata & {
  license?: string, // License "title" ex: Creative Commons, Custom copyright
  license_url?: string, // Link to full license
@ -136,3 +144,71 @@ declare type PurchaseReceipt = {
  txid: string,
  type: 'purchase',
 };
+
+declare type ClaimActionResolveInfo = {
+  [string]: {
+    stream: ?StreamClaim,
+    channel: ?ChannelClaim,
+    claimsInChannel: ?number,
+    collection: ?CollectionClaim,
+  },
+}
+
+declare type ChannelUpdateParams = {
+  claim_id: string,
+  bid?: string,
+  title?: string,
+  cover_url?: string,
+  thumbnail_url?: string,
+  description?: string,
+  website_url?: string,
+  email?: string,
+  tags?: Array<string>,
+  replace?: boolean,
+  languages?: Array<string>,
+  locations?: Array<string>,
+  blocking?: boolean,
+}
+
+declare type ChannelPublishParams = {
+  name: string,
+  bid: string,
+  blocking?: true,
+  title?: string,
+  cover_url?: string,
+  thumbnail_url?: string,
+  description?: string,
+  website_url?: string,
+  email?: string,
+  tags?: Array<string>,
+  languages?: Array<string>,
+}
+
+declare type CollectionUpdateParams = {
+  claim_id: string,
+  claim_ids?: Array<string>,
+  bid?: string,
+  title?: string,
+  cover_url?: string,
+  thumbnail_url?: string,
+  description?: string,
+  website_url?: string,
+  email?: string,
+  tags?: Array<string>,
+  replace?: boolean,
+  languages?: Array<string>,
+  locations?: Array<string>,
+  blocking?: boolean,
+}
+
+declare type CollectionPublishParams = {
+  name: string,
+  bid: string,
+  claim_ids: Array<string>,
+  blocking?: true,
+  title?: string,
+  thumbnail_url?: string,
+  description?: string,
+  tags?: Array<string>,
+  languages?: Array<string>,
+}
--- a/dist/flow-typed/Collections.js
+++ b/dist/flow-typed/Collections.js
@ -0,0 +1,34 @@
+declare type Collection = {
+  id: string,
+  items: Array<?string>,
+  name: string,
+  type: string,
+  updatedAt: number,
+  totalItems?: number,
+  sourceId?: string, // if copied, claimId of original collection
+};
+
+declare type CollectionState = {
+  unpublished: CollectionGroup,
+  resolved: CollectionGroup,
+  pending: CollectionGroup,
+  edited: CollectionGroup,
+  builtin: CollectionGroup,
+  saved: Array<string>,
+  isResolvingCollectionById: { [string]: boolean },
+  error?: string | null,
+};
+
+declare type CollectionGroup = {
+  [string]: Collection,
+}
+
+declare type CollectionEditParams = {
+  claims?: Array<Claim>,
+  remove?: boolean,
+  claimIds?: Array<string>,
+  replace?: boolean,
+  order?: { from: number, to: number },
+  type?: string,
+  name?: string,
+}
--- a/dist/flow-typed/Lbry.js
+++ b/dist/flow-typed/Lbry.js
@ -75,7 +75,7 @@ declare type BalanceResponse = {

 declare type ResolveResponse = {
  // Keys are the url(s) passed to resolve
-  [string]: { error?: {}, stream?: StreamClaim, channel?: ChannelClaim, claimsInChannel?: number },
+  [string]: { error?: {}, stream?: StreamClaim, channel?: ChannelClaim, collection?: CollectionClaim, claimsInChannel?: number },
 };

 declare type GetResponse = FileListItem & { error?: string };
@ -124,14 +124,6 @@ declare type ChannelUpdateResponse = GenericTxResponse & {
 declare type CommentCreateResponse = Comment;
 declare type CommentUpdateResponse = Comment;

-declare type CommentListResponse = {
-  items: Array<Comment>,
-  page: number,
-  page_size: number,
-  total_items: number,
-  total_pages: number,
-};
-
 declare type MyReactions = {
  // Keys are the commentId
  [string]: Array<string>,
@ -178,6 +170,37 @@ declare type ChannelSignResponse = {
  signing_ts: string,
 };

+declare type CollectionCreateResponse = {
+  outputs: Array<Claim>,
+  page: number,
+  page_size: number,
+  total_items: number,
+  total_pages: number,
+}
+
+declare type CollectionListResponse = {
+  items: Array<Claim>,
+  page: number,
+  page_size: number,
+  total_items: number,
+  total_pages: number,
+};
+
+declare type CollectionResolveResponse = {
+  items: Array<Claim>,
+  total_items: number,
+};
+
+declare type CollectionResolveOptions = {
+  claim_id: string,
+};
+
+declare type CollectionListOptions = {
+  page: number,
+  page_size: number,
+  resolve?: boolean,
+};
+
 declare type FileListResponse = {
  items: Array<FileListItem>,
  page: number,
@ -296,6 +319,10 @@ declare type LbryTypes = {
  support_abandon: (params: {}) => Promise<SupportAbandonResponse>,
  stream_repost: (params: StreamRepostOptions) => Promise<StreamRepostResponse>,
  purchase_list: (params: PurchaseListOptions) => Promise<PurchaseListResponse>,
+  collection_resolve: (params: CollectionResolveOptions) => Promise<CollectionResolveResponse>,
+  collection_list: (params: CollectionListOptions) => Promise<CollectionListResponse>,
+  collection_create: (params: {}) => Promise<CollectionCreateResponse>,
+  collection_update: (params: {}) => Promise<CollectionCreateResponse>,

  // File fetching and manipulation
  file_list: (params: {}) => Promise<FileListResponse>,
@ -308,8 +335,6 @@ declare type LbryTypes = {
  preference_set: (params: {}) => Promise<any>,

  // Commenting
-  comment_list: (params: {}) => Promise<CommentListResponse>,
-  comment_create: (params: {}) => Promise<CommentCreateResponse>,
  comment_update: (params: {}) => Promise<CommentUpdateResponse>,
  comment_hide: (params: {}) => Promise<CommentHideResponse>,
  comment_abandon: (params: {}) => Promise<CommentAbandonResponse>,
@ -326,6 +351,7 @@ declare type LbryTypes = {
  address_unused: (params: {}) => Promise<string>, // New address
  address_list: (params: {}) => Promise<string>,
  transaction_list: (params: {}) => Promise<TxListResponse>,
+  txo_list: (params: {}) => Promise<any>,

  // Sync
  sync_hash: (params: {}) => Promise<string>,
--- a/dist/flow-typed/npm/from-entries.js
+++ b/dist/flow-typed/npm/from-entries.js
@ -0,0 +1,5 @@
+// @flow
+
+declare module '@ungap/from-entries' {
+  declare module.exports: any;
+}
--- a/flow-typed/Claim.js
+++ b/flow-typed/Claim.js
@ -1,11 +1,15 @@
 // @flow

-declare type Claim = StreamClaim | ChannelClaim;
+declare type Claim = StreamClaim | ChannelClaim | CollectionClaim;

 declare type ChannelClaim = GenericClaim & {
  value: ChannelMetadata,
 };

+declare type CollectionClaim = GenericClaim & {
+  value: CollectionMetadata,
+};
+
 declare type StreamClaim = GenericClaim & {
  value: StreamMetadata,
 };
@ -30,7 +34,7 @@ declare type GenericClaim = {
  short_url: string, // permanent_url with short id, no channel
  txid: string, // unique tx id
  type: 'claim' | 'update' | 'support',
-  value_type: 'stream' | 'channel',
+  value_type: 'stream' | 'channel' | 'collection',
  signing_channel?: ChannelClaim,
  reposted_claim?: GenericClaim,
  repost_channel_url?: string,
@ -74,6 +78,10 @@ declare type ChannelMetadata = GenericMetadata & {
  featured?: Array<string>,
 };

+declare type CollectionMetadata = GenericMetadata & {
+  claims: Array<string>,
+}
+
 declare type StreamMetadata = GenericMetadata & {
  license?: string, // License "title" ex: Creative Commons, Custom copyright
  license_url?: string, // Link to full license
@ -136,3 +144,71 @@ declare type PurchaseReceipt = {
  txid: string,
  type: 'purchase',
 };
+
+declare type ClaimActionResolveInfo = {
+  [string]: {
+    stream: ?StreamClaim,
+    channel: ?ChannelClaim,
+    claimsInChannel: ?number,
+    collection: ?CollectionClaim,
+  },
+}
+
+declare type ChannelUpdateParams = {
+  claim_id: string,
+  bid?: string,
+  title?: string,
+  cover_url?: string,
+  thumbnail_url?: string,
+  description?: string,
+  website_url?: string,
+  email?: string,
+  tags?: Array<string>,
+  replace?: boolean,
+  languages?: Array<string>,
+  locations?: Array<string>,
+  blocking?: boolean,
+}
+
+declare type ChannelPublishParams = {
+  name: string,
+  bid: string,
+  blocking?: true,
+  title?: string,
+  cover_url?: string,
+  thumbnail_url?: string,
+  description?: string,
+  website_url?: string,
+  email?: string,
+  tags?: Array<string>,
+  languages?: Array<string>,
+}
+
+declare type CollectionUpdateParams = {
+  claim_id: string,
+  claim_ids?: Array<string>,
+  bid?: string,
+  title?: string,
+  cover_url?: string,
+  thumbnail_url?: string,
+  description?: string,
+  website_url?: string,
+  email?: string,
+  tags?: Array<string>,
+  replace?: boolean,
+  languages?: Array<string>,
+  locations?: Array<string>,
+  blocking?: boolean,
+}
+
+declare type CollectionPublishParams = {
+  name: string,
+  bid: string,
+  claim_ids: Array<string>,
+  blocking?: true,
+  title?: string,
+  thumbnail_url?: string,
+  description?: string,
+  tags?: Array<string>,
+  languages?: Array<string>,
+}
--- a/flow-typed/Collections.js
+++ b/flow-typed/Collections.js
@ -0,0 +1,34 @@
+declare type Collection = {
+  id: string,
+  items: Array<?string>,
+  name: string,
+  type: string,
+  updatedAt: number,
+  totalItems?: number,
+  sourceId?: string, // if copied, claimId of original collection
+};
+
+declare type CollectionState = {
+  unpublished: CollectionGroup,
+  resolved: CollectionGroup,
+  pending: CollectionGroup,
+  edited: CollectionGroup,
+  builtin: CollectionGroup,
+  saved: Array<string>,
+  isResolvingCollectionById: { [string]: boolean },
+  error?: string | null,
+};
+
+declare type CollectionGroup = {
+  [string]: Collection,
+}
+
+declare type CollectionEditParams = {
+  claims?: Array<Claim>,
+  remove?: boolean,
+  claimIds?: Array<string>,
+  replace?: boolean,
+  order?: { from: number, to: number },
+  type?: string,
+  name?: string,
+}
--- a/flow-typed/Lbry.js
+++ b/flow-typed/Lbry.js
@ -75,7 +75,7 @@ declare type BalanceResponse = {

 declare type ResolveResponse = {
  // Keys are the url(s) passed to resolve
-  [string]: { error?: {}, stream?: StreamClaim, channel?: ChannelClaim, claimsInChannel?: number },
+  [string]: { error?: {}, stream?: StreamClaim, channel?: ChannelClaim, collection?: CollectionClaim, claimsInChannel?: number },
 };

 declare type GetResponse = FileListItem & { error?: string };
@ -124,14 +124,6 @@ declare type ChannelUpdateResponse = GenericTxResponse & {
 declare type CommentCreateResponse = Comment;
 declare type CommentUpdateResponse = Comment;

-declare type CommentListResponse = {
-  items: Array<Comment>,
-  page: number,
-  page_size: number,
-  total_items: number,
-  total_pages: number,
-};
-
 declare type MyReactions = {
  // Keys are the commentId
  [string]: Array<string>,
@ -178,6 +170,37 @@ declare type ChannelSignResponse = {
  signing_ts: string,
 };

+declare type CollectionCreateResponse = {
+  outputs: Array<Claim>,
+  page: number,
+  page_size: number,
+  total_items: number,
+  total_pages: number,
+}
+
+declare type CollectionListResponse = {
+  items: Array<Claim>,
+  page: number,
+  page_size: number,
+  total_items: number,
+  total_pages: number,
+};
+
+declare type CollectionResolveResponse = {
+  items: Array<Claim>,
+  total_items: number,
+};
+
+declare type CollectionResolveOptions = {
+  claim_id: string,
+};
+
+declare type CollectionListOptions = {
+  page: number,
+  page_size: number,
+  resolve?: boolean,
+};
+
 declare type FileListResponse = {
  items: Array<FileListItem>,
  page: number,
@ -296,6 +319,10 @@ declare type LbryTypes = {
  support_abandon: (params: {}) => Promise<SupportAbandonResponse>,
  stream_repost: (params: StreamRepostOptions) => Promise<StreamRepostResponse>,
  purchase_list: (params: PurchaseListOptions) => Promise<PurchaseListResponse>,
+  collection_resolve: (params: CollectionResolveOptions) => Promise<CollectionResolveResponse>,
+  collection_list: (params: CollectionListOptions) => Promise<CollectionListResponse>,
+  collection_create: (params: {}) => Promise<CollectionCreateResponse>,
+  collection_update: (params: {}) => Promise<CollectionCreateResponse>,

  // File fetching and manipulation
  file_list: (params: {}) => Promise<FileListResponse>,
@ -308,8 +335,6 @@ declare type LbryTypes = {
  preference_set: (params: {}) => Promise<any>,

  // Commenting
-  comment_list: (params: {}) => Promise<CommentListResponse>,
-  comment_create: (params: {}) => Promise<CommentCreateResponse>,
  comment_update: (params: {}) => Promise<CommentUpdateResponse>,
  comment_hide: (params: {}) => Promise<CommentHideResponse>,
  comment_abandon: (params: {}) => Promise<CommentAbandonResponse>,
@ -326,6 +351,7 @@ declare type LbryTypes = {
  address_unused: (params: {}) => Promise<string>, // New address
  address_list: (params: {}) => Promise<string>,
  transaction_list: (params: {}) => Promise<TxListResponse>,
+  txo_list: (params: {}) => Promise<any>,

  // Sync
  sync_hash: (params: {}) => Promise<string>,
--- a/flow-typed/npm/from-entries.js
+++ b/flow-typed/npm/from-entries.js
@ -0,0 +1,5 @@
+// @flow
+
+declare module '@ungap/from-entries' {
+  declare module.exports: any;
+}
--- a/package.json
+++ b/package.json
@ -29,6 +29,7 @@
    "test": "jest"
  },
  "dependencies": {
+    "@ungap/from-entries": "^0.2.1",
    "proxy-polyfill": "0.1.6",
    "reselect": "^3.0.0",
    "uuid": "^8.3.1"
--- a/src/constants/action_types.js
+++ b/src/constants/action_types.js
@ -102,6 +102,9 @@ export const ABANDON_CLAIM_SUCCEEDED = 'ABANDON_CLAIM_SUCCEEDED';
 export const FETCH_CHANNEL_LIST_STARTED = 'FETCH_CHANNEL_LIST_STARTED';
 export const FETCH_CHANNEL_LIST_COMPLETED = 'FETCH_CHANNEL_LIST_COMPLETED';
 export const FETCH_CHANNEL_LIST_FAILED = 'FETCH_CHANNEL_LIST_FAILED';
+export const FETCH_COLLECTION_LIST_STARTED = 'FETCH_COLLECTION_LIST_STARTED';
+export const FETCH_COLLECTION_LIST_COMPLETED = 'FETCH_COLLECTION_LIST_COMPLETED';
+export const FETCH_COLLECTION_LIST_FAILED = 'FETCH_COLLECTION_LIST_FAILED';
 export const CREATE_CHANNEL_STARTED = 'CREATE_CHANNEL_STARTED';
 export const CREATE_CHANNEL_COMPLETED = 'CREATE_CHANNEL_COMPLETED';
 export const CREATE_CHANNEL_FAILED = 'CREATE_CHANNEL_FAILED';
@ -111,6 +114,7 @@ export const UPDATE_CHANNEL_FAILED = 'UPDATE_CHANNEL_FAILED';
 export const IMPORT_CHANNEL_STARTED = 'IMPORT_CHANNEL_STARTED';
 export const IMPORT_CHANNEL_COMPLETED = 'IMPORT_CHANNEL_COMPLETED';
 export const IMPORT_CHANNEL_FAILED = 'IMPORT_CHANNEL_FAILED';
+export const CLEAR_CHANNEL_ERRORS = 'CLEAR_CHANNEL_ERRORS';
 export const PUBLISH_STARTED = 'PUBLISH_STARTED';
 export const PUBLISH_COMPLETED = 'PUBLISH_COMPLETED';
 export const PUBLISH_FAILED = 'PUBLISH_FAILED';
@ -129,7 +133,6 @@ export const CLAIM_REPOST_STARTED = 'CLAIM_REPOST_STARTED';
 export const CLAIM_REPOST_COMPLETED = 'CLAIM_REPOST_COMPLETED';
 export const CLAIM_REPOST_FAILED = 'CLAIM_REPOST_FAILED';
 export const CLEAR_REPOST_ERROR = 'CLEAR_REPOST_ERROR';
-export const CLEAR_CHANNEL_ERRORS = 'CLEAR_CHANNEL_ERRORS';
 export const CHECK_PUBLISH_NAME_STARTED = 'CHECK_PUBLISH_NAME_STARTED';
 export const CHECK_PUBLISH_NAME_COMPLETED = 'CHECK_PUBLISH_NAME_COMPLETED';
 export const UPDATE_PENDING_CLAIMS = 'UPDATE_PENDING_CLAIMS';
@ -142,6 +145,27 @@ export const PURCHASE_LIST_STARTED = 'PURCHASE_LIST_STARTED';
 export const PURCHASE_LIST_COMPLETED = 'PURCHASE_LIST_COMPLETED';
 export const PURCHASE_LIST_FAILED = 'PURCHASE_LIST_FAILED';

+export const COLLECTION_PUBLISH_STARTED = 'COLLECTION_PUBLISH_STARTED';
+export const COLLECTION_PUBLISH_COMPLETED = 'COLLECTION_PUBLISH_COMPLETED';
+export const COLLECTION_PUBLISH_FAILED = 'COLLECTION_PUBLISH_FAILED';
+export const COLLECTION_PUBLISH_UPDATE_STARTED = 'COLLECTION_PUBLISH_UPDATE_STARTED';
+export const COLLECTION_PUBLISH_UPDATE_COMPLETED = 'COLLECTION_PUBLISH_UPDATE_COMPLETED';
+export const COLLECTION_PUBLISH_UPDATE_FAILED = 'COLLECTION_PUBLISH_UPDATE_FAILED';
+export const COLLECTION_PUBLISH_ABANDON_STARTED = 'COLLECTION_PUBLISH_ABANDON_STARTED';
+export const COLLECTION_PUBLISH_ABANDON_COMPLETED = 'COLLECTION_PUBLISH_ABANDON_COMPLETED';
+export const COLLECTION_PUBLISH_ABANDON_FAILED = 'COLLECTION_PUBLISH_ABANDON_FAILED';
+export const CLEAR_COLLECTION_ERRORS = 'CLEAR_COLLECTION_ERRORS';
+export const COLLECTION_ITEMS_RESOLVE_STARTED = 'COLLECTION_ITEMS_RESOLVE_STARTED';
+export const COLLECTION_ITEMS_RESOLVE_COMPLETED = 'COLLECTION_ITEMS_RESOLVE_COMPLETED';
+export const COLLECTION_ITEMS_RESOLVE_FAILED = 'COLLECTION_ITEMS_RESOLVE_FAILED';
+export const COLLECTION_NEW = 'COLLECTION_NEW';
+export const COLLECTION_DELETE = 'COLLECTION_DELETE';
+export const COLLECTION_PENDING = 'COLLECTION_PENDING';
+export const COLLECTION_EDIT = 'COLLECTION_EDIT';
+export const COLLECTION_COPY = 'COLLECTION_COPY';
+export const COLLECTION_SAVE = 'COLLECTION_SAVE';
+export const COLLECTION_ERROR = 'COLLECTION_ERROR';
+
 // Comments
 export const COMMENT_LIST_STARTED = 'COMMENT_LIST_STARTED';
 export const COMMENT_LIST_COMPLETED = 'COMMENT_LIST_COMPLETED';
--- a/src/constants/collections.js
+++ b/src/constants/collections.js
@ -0,0 +1,15 @@
+export const COLLECTION_ID = 'lid';
+export const COLLECTION_INDEX = 'linx';
+
+export const COL_TYPE_PLAYLIST = 'playlist';
+export const COL_TYPE_CHANNELS = 'channelList';
+
+export const WATCH_LATER_ID = 'watchlater';
+export const FAVORITES_ID = 'favorites';
+export const FAVORITE_CHANNELS_ID = 'favoriteChannels';
+export const BUILTIN_LISTS = [WATCH_LATER_ID, FAVORITES_ID, FAVORITE_CHANNELS_ID];
+
+export const COL_KEY_EDITED = 'edited';
+export const COL_KEY_UNPUBLISHED = 'unpublished';
+export const COL_KEY_PENDING = 'pending';
+export const COL_KEY_SAVED = 'saved';
--- a/src/constants/settings.js
+++ b/src/constants/settings.js
@ -23,7 +23,7 @@ export const INSTANT_PURCHASE_MAX = 'instant_purchase_max';
 export const THEME = 'theme';
 export const THEMES = 'themes';
 export const AUTOMATIC_DARK_MODE_ENABLED = 'automatic_dark_mode_enabled';
-export const AUTOPLAY = 'autoplay';
+export const AUTOPLAY_MEDIA = 'autoplay';
 export const AUTOPLAY_NEXT = 'autoplay_next';
 export const OS_NOTIFICATIONS_ENABLED = 'os_notifications_enabled';
 export const AUTO_DOWNLOAD = 'auto_download';
@ -39,6 +39,8 @@ export const ENABLE_PUBLISH_PREVIEW = 'enable-publish-preview';
 export const TILE_LAYOUT = 'tile_layout';
 export const VIDEO_THEATER_MODE = 'video_theater_mode';
 export const VIDEO_PLAYBACK_RATE = 'video_playback_rate';
+export const CUSTOM_COMMENTS_SERVER_ENABLED = 'custom_comments_server_enabled';
+export const CUSTOM_COMMENTS_SERVER_URL = 'custom_comments_server_url';

 // mobile settings
 export const BACKGROUND_PLAY_ENABLED = 'backgroundPlayEnabled';
--- a/src/constants/shared_preferences.js
+++ b/src/constants/shared_preferences.js
@ -21,10 +21,12 @@ export const CLIENT_SYNC_KEYS = [
  SETTINGS.INSTANT_PURCHASE_ENABLED,
  SETTINGS.INSTANT_PURCHASE_MAX,
  SETTINGS.THEME,
-  SETTINGS.AUTOPLAY,
+  SETTINGS.AUTOPLAY_MEDIA,
+  SETTINGS.AUTOPLAY_NEXT,
  SETTINGS.HIDE_BALANCE,
  SETTINGS.HIDE_SPLASH_ANIMATION,
  SETTINGS.FLOATING_PLAYER,
  SETTINGS.DARK_MODE_TIMES,
  SETTINGS.AUTOMATIC_DARK_MODE_ENABLED,
+  SETTINGS.LANGUAGE,
 ];
--- a/src/index.js
+++ b/src/index.js
@ -12,6 +12,7 @@ import * as TXO_LIST from 'constants/txo_list';
 import * as SPEECH_URLS from 'constants/speech_urls';
 import * as DAEMON_SETTINGS from 'constants/daemon_settings';
 import * as SHARED_PREFERENCES from 'constants/shared_preferences';
+import * as COLLECTIONS_CONSTS from 'constants/collections';
 import { DEFAULT_KNOWN_TAGS, DEFAULT_FOLLOWED_TAGS, MATURE_TAGS } from 'constants/tags';
 import Lbry, { apiCall } from 'lbry';
 import LbryFirst from 'lbry-first';
@ -35,6 +36,7 @@ export {
  MATURE_TAGS,
  SPEECH_URLS,
  SHARED_PREFERENCES,
+  COLLECTIONS_CONSTS,
 };

 // common
@ -50,6 +52,8 @@ export {
  isURIClaimable,
  isNameValid,
  convertToShareLink,
+  splitBySeparator,
+  isURIEqual,
 } from 'lbryURI';

 // middlware
@ -57,6 +61,13 @@ export { buildSharedStateMiddleware } from 'redux/middleware/shared-state';

 // actions
 export { doToast, doDismissToast, doError, doDismissError } from 'redux/actions/notifications';
+export {
+  doLocalCollectionCreate,
+  doFetchItemsInCollection,
+  doFetchItemsInCollections,
+  doCollectionEdit,
+  doCollectionDelete,
+} from 'redux/actions/collections';

 export {
  doFetchClaimsByChannel,
@ -66,6 +77,7 @@ export {
  doResolveUris,
  doResolveUri,
  doFetchChannelListMine,
+  doFetchCollectionListMine,
  doCreateChannel,
  doUpdateChannel,
  doClaimSearch,
@ -76,6 +88,8 @@ export {
  doCheckPublishNameAvailability,
  doPurchaseList,
  doCheckPendingClaims,
+  doCollectionPublish,
+  doCollectionPublishUpdate,
 } from 'redux/actions/claims';

 export { doClearPurchasedUriSuccess, doPurchaseUri, doFileGet } from 'redux/actions/file';
@ -140,11 +154,39 @@ export { fileInfoReducer } from 'redux/reducers/file_info';
 export { notificationsReducer } from 'redux/reducers/notifications';
 export { publishReducer } from 'redux/reducers/publish';
 export { walletReducer } from 'redux/reducers/wallet';
+export { collectionsReducer } from 'redux/reducers/collections';

 // selectors
 export { makeSelectContentPositionForUri } from 'redux/selectors/content';

 export { selectToast, selectError } from 'redux/selectors/notifications';
+export {
+  selectSavedCollectionIds,
+  selectBuiltinCollections,
+  selectResolvedCollections,
+  selectMyUnpublishedCollections,
+  selectMyEditedCollections,
+  selectMyPublishedCollections,
+  selectMyPublishedMixedCollections,
+  selectMyPublishedPlaylistCollections,
+  makeSelectEditedCollectionForId,
+  makeSelectPendingCollectionForId,
+  makeSelectPublishedCollectionForId,
+  makeSelectCollectionIsMine,
+  makeSelectMyPublishedCollectionForId,
+  makeSelectUnpublishedCollectionForId,
+  makeSelectCollectionForId,
+  makeSelectClaimUrlInCollection,
+  makeSelectUrlsForCollectionId,
+  makeSelectClaimIdsForCollectionId,
+  makeSelectNameForCollectionId,
+  makeSelectCountForCollectionId,
+  makeSelectIsResolvingCollectionForId,
+  makeSelectIndexForUrlInCollection,
+  makeSelectPreviousUrlForCollectionAndUrl,
+  makeSelectNextUrlForCollectionAndUrl,
+  makeSelectCollectionForIdHasClaimUrl,
+} from 'redux/selectors/collections';

 export {
  makeSelectClaimForUri,
@ -171,7 +213,6 @@ export {
  makeSelectTotalItemsForChannel,
  makeSelectTotalPagesForChannel,
  makeSelectNsfwCountFromUris,
-  makeSelectNsfwCountForChannel,
  makeSelectOmittedCountForChannel,
  makeSelectClaimIsNsfw,
  makeSelectChannelForClaimUri,
@ -179,7 +220,6 @@ export {
  makeSelectMyChannelPermUrlForName,
  makeSelectClaimIsPending,
  makeSelectReflectingClaimForUri,
-  makeSelectClaimsInChannelForCurrentPageState,
  makeSelectShortUrlForUri,
  makeSelectCanonicalUrlForUri,
  makeSelectPermanentUrlForUri,
@ -209,6 +249,8 @@ export {
  selectAllMyClaimsByOutpoint,
  selectMyClaimsOutpoints,
  selectFetchingMyChannels,
+  selectFetchingMyCollections,
+  selectMyCollectionIds,
  selectMyChannelClaims,
  selectResolvingUris,
  selectPlayingUri,
@ -237,6 +279,12 @@ export {
  selectFetchingMyPurchasesError,
  selectMyPurchasesCount,
  selectPurchaseUriSuccess,
+  makeSelectClaimIdForUri,
+  selectUpdatingCollection,
+  selectUpdateCollectionError,
+  selectCreatingCollection,
+  selectCreateCollectionError,
+  makeSelectClaimIdIsPending,
 } from 'redux/selectors/claims';

 export {
@ -285,6 +333,7 @@ export {
  selectSupportsByOutpoint,
  selectTotalSupports,
  selectTransactionItems,
+  selectTransactionsFile,
  selectRecentTransactions,
  selectHasTransactions,
  selectIsFetchingTransactions,
--- a/src/lbry.js
+++ b/src/lbry.js
@ -90,6 +90,10 @@ const Lbry: LbryTypes = {
  support_create: params => daemonCallWithResult('support_create', params),
  support_list: params => daemonCallWithResult('support_list', params),
  stream_repost: params => daemonCallWithResult('stream_repost', params),
+  collection_resolve: params => daemonCallWithResult('collection_resolve', params),
+  collection_list: params => daemonCallWithResult('collection_list', params),
+  collection_create: params => daemonCallWithResult('collection_create', params),
+  collection_update: params => daemonCallWithResult('collection_update', params),

  // File fetching and manipulation
  file_list: (params = {}) => daemonCallWithResult('file_list', params),
@ -113,6 +117,7 @@ const Lbry: LbryTypes = {
  utxo_release: (params = {}) => daemonCallWithResult('utxo_release', params),
  support_abandon: (params = {}) => daemonCallWithResult('support_abandon', params),
  purchase_list: (params = {}) => daemonCallWithResult('purchase_list', params),
+  txo_list: (params = {}) => daemonCallWithResult('txo_list', params),

  sync_hash: (params = {}) => daemonCallWithResult('sync_hash', params),
  sync_apply: (params = {}) => daemonCallWithResult('sync_apply', params),
--- a/src/lbryURI.js
+++ b/src/lbryURI.js
@ -4,7 +4,7 @@ const channelNameMinLength = 1;
 const claimIdMaxLength = 40;

 // see https://spec.lbry.com/#urls
-export const regexInvalidURI = /[ =&#:$@%?;/\\"<>%\{\}|^~[\]`\u{0000}-\u{0008}\u{000b}-\u{000c}\u{000e}-\u{001F}\u{D800}-\u{DFFF}\u{FFFE}-\u{FFFF}]/u;
+export const regexInvalidURI = /[ =&#:$@%?;/\\"<>%{}|^~[\]`\u{0000}-\u{0008}\u{000b}-\u{000c}\u{000e}-\u{001F}\u{D800}-\u{DFFF}\u{FFFE}-\u{FFFF}]/u;
 export const regexAddress = /^(b|r)(?=[^0OIl]{32,33})[0-9A-Za-z]{32,33}$/;
 const regexPartProtocol = '^((?:lbry://)?)';
 const regexPartStreamOrChannelName = '([^:$#/]*)';
@ -12,6 +12,11 @@ const regexPartModifierSeparator = '([:$#]?)([^/]*)';
 const queryStringBreaker = '^([\\S]+)([?][\\S]*)';
 const separateQuerystring = new RegExp(queryStringBreaker);

+const MOD_SEQUENCE_SEPARATOR = '*';
+const MOD_CLAIM_ID_SEPARATOR_OLD = '#';
+const MOD_CLAIM_ID_SEPARATOR = ':';
+const MOD_BID_POSITION_SEPARATOR = '$';
+
 /**
 * Parses a LBRY name into its component parts. Throws errors with user-friendly
 * messages for invalid names.
@ -144,11 +149,11 @@ function parseURIModifier(modSeperator: ?string, modValue: ?string) {
      throw new Error(__(`No modifier provided after separator %modSeperator%.`, { modSeperator }));
    }

-    if (modSeperator === '#') {
+    if (modSeperator === MOD_CLAIM_ID_SEPARATOR || MOD_CLAIM_ID_SEPARATOR_OLD) {
      claimId = modValue;
-    } else if (modSeperator === ':') {
+    } else if (modSeperator === MOD_SEQUENCE_SEPARATOR) {
      claimSequence = modValue;
-    } else if (modSeperator === '$') {
+    } else if (modSeperator === MOD_BID_POSITION_SEPARATOR) {
      bidPosition = modValue;
    }
  }
@ -320,3 +325,22 @@ export function convertToShareLink(URL: string) {
    'https://open.lbry.com/'
  );
 }
+
+export function splitBySeparator(uri: string) {
+  const protocolLength = 7;
+  return uri.startsWith('lbry://') ? uri.slice(protocolLength).split(/[#:*]/) : uri.split(/#:\*\$/);
+}
+
+export function isURIEqual(uriA: string, uriB: string) {
+  const parseA = parseURI(normalizeURI(uriA));
+  const parseB = parseURI(normalizeURI(uriB));
+  if (parseA.isChannel) {
+    if (parseB.isChannel && parseA.channelClaimId === parseB.channelClaimId) {
+      return true;
+    }
+  } else if (parseA.streamClaimId === parseB.streamClaimId) {
+    return true;
+  } else {
+    return false;
+  }
+}
--- a/src/redux/actions/claims.js
+++ b/src/redux/actions/claims.js
@ -10,16 +10,27 @@ import {
  selectClaimsByUri,
  selectMyChannelClaims,
  selectPendingIds,
-  selectClaimsById,
+  selectPendingClaimsById,
 } from 'redux/selectors/claims';
+
 import { doFetchTxoPage } from 'redux/actions/wallet';
 import { selectSupportsByOutpoint } from 'redux/selectors/wallet';
 import { creditsToString } from 'util/format-credits';
 import { batchActions } from 'util/batch-actions';
 import { createNormalizedClaimSearchKey } from 'util/claim';
 import { PAGE_SIZE } from 'constants/claim';
+import {
+  selectPendingCollections,
+  makeSelectClaimIdsForCollectionId,
+} from 'redux/selectors/collections';
+import {
+  doFetchItemsInCollection,
+  doFetchItemsInCollections,
+  doCollectionDelete,
+} from 'redux/actions/collections';

-type ResolveEntries = Array<[string, GenericClaim]>;
+let onChannelConfirmCallback;
+let checkPendingInterval;

 export function doResolveUris(
  uris: Array<string>,
@ -61,11 +72,14 @@ export function doResolveUris(
        stream: ?StreamClaim,
        channel: ?ChannelClaim,
        claimsInChannel: ?number,
+        collection: ?CollectionClaim,
      },
    } = {};

+    const collectionIds: Array<string> = [];
+
    return Lbry.resolve({ urls: urisToResolve, ...options }).then(
-      async (result: ResolveResponse) => {
+      async(result: ResolveResponse) => {
        let repostedResults = {};
        const repostsToResolve = [];
        const fallbackResolveInfo = {
@ -80,6 +94,7 @@ export function doResolveUris(
            // https://github.com/facebook/flow/issues/2221
            if (uriResolveInfo) {
              if (uriResolveInfo.error) {
+                // $FlowFixMe
                resolveInfo[uri] = { ...fallbackResolveInfo };
              } else {
                if (checkReposts) {
@ -96,6 +111,10 @@ export function doResolveUris(
                  result.channel = uriResolveInfo;
                  // $FlowFixMe
                  result.claimsInChannel = uriResolveInfo.meta.claims_in_channel;
+                } else if (uriResolveInfo.value_type === 'collection') {
+                  result.collection = uriResolveInfo;
+                  // $FlowFixMe
+                  collectionIds.push(uriResolveInfo.claim_id);
                } else {
                  result.stream = uriResolveInfo;
                  if (uriResolveInfo.signing_channel) {
@ -127,6 +146,11 @@ export function doResolveUris(
          type: ACTIONS.RESOLVE_URIS_COMPLETED,
          data: { resolveInfo },
        });
+
+        if (collectionIds.length) {
+          dispatch(doFetchItemsInCollections({ collectionIds: collectionIds, pageSize: 5 }));
+        }
+
        return result;
      }
    );
@ -383,7 +407,7 @@ export function doClearChannelErrors() {
  };
 }

-export function doCreateChannel(name: string, amount: number, optionalParams: any, cb: any) {
+export function doCreateChannel(name: string, amount: number, optionalParams: any, onConfirm: any) {
  return (dispatch: Dispatch) => {
    dispatch({
      type: ACTIONS.CREATE_CHANNEL_STARTED,
@ -399,7 +423,7 @@ export function doCreateChannel(name: string, amount: number, optionalParams: an
      description?: string,
      website_url?: string,
      email?: string,
-      tags?: Array<string>,
+      tags?: Array<Tag>,
      languages?: Array<string>,
    } = {
      name,
@ -450,7 +474,7 @@ export function doCreateChannel(name: string, amount: number, optionalParams: an
              claims: [channelClaim],
            },
          });
-          dispatch(doCheckPendingClaims(cb));
+          dispatch(doCheckPendingClaims(onConfirm));
          return channelClaim;
        })
        .catch(error => {
@ -493,7 +517,6 @@ export function doUpdateChannel(params: any, cb: any) {
    }

    // we'll need to remove these once we add locations/channels to channel page edit/create options
-
    if (channelClaim && channelClaim.value && channelClaim.value.locations) {
      updateParams.locations = channelClaim.value.locations;
    }
@ -531,7 +554,7 @@ export function doImportChannel(certificate: string) {
    });

    return Lbry.channel_import({ channel_data: certificate })
-      .then((result: string) => {
+      .then(() => {
        dispatch({
          type: ACTIONS.IMPORT_CHANNEL_COMPLETED,
        });
@ -573,11 +596,45 @@ export function doFetchChannelListMine(
  };
 }

+export function doFetchCollectionListMine(page: number = 1, pageSize: number = 99999) {
+  return (dispatch: Dispatch) => {
+    dispatch({
+      type: ACTIONS.FETCH_COLLECTION_LIST_STARTED,
+    });
+
+    const callback = (response: CollectionListResponse) => {
+      const { items } = response;
+      dispatch({
+        type: ACTIONS.FETCH_COLLECTION_LIST_COMPLETED,
+        data: { claims: items },
+      });
+      dispatch(
+        doFetchItemsInCollections({
+          collectionIds: items.map(claim => claim.claim_id),
+          page_size: 5,
+        })
+      );
+    };
+
+    const failure = error => {
+      dispatch({
+        type: ACTIONS.FETCH_COLLECTION_LIST_FAILED,
+        data: error,
+      });
+    };
+
+    Lbry.collection_list({ page, page_size: pageSize, resolve_claims: 1, resolve: true }).then(
+      callback,
+      failure
+    );
+  };
+}
+
 export function doClaimSearch(
  options: {
    page_size: number,
    page: number,
-    no_totals: boolean,
+    no_totals?: boolean,
    any_tags?: Array<string>,
    claim_ids?: Array<string>,
    channel_ids?: Array<string>,
@ -594,7 +651,7 @@ export function doClaimSearch(
  }
 ) {
  const query = createNormalizedClaimSearchKey(options);
-  return (dispatch: Dispatch) => {
+  return async(dispatch: Dispatch) => {
    dispatch({
      type: ACTIONS.CLAIM_SEARCH_STARTED,
      data: { query: query },
@ -618,6 +675,7 @@ export function doClaimSearch(
          pageSize: options.page_size,
        },
      });
+      return resolveInfo;
    };

    const failure = err => {
@ -626,9 +684,10 @@ export function doClaimSearch(
        data: { query },
        error: err,
      });
+      return false;
    };

-    Lbry.claim_search({
+    return await Lbry.claim_search({
      ...options,
      include_purchase_receipt: true,
    }).then(success, failure);
@ -636,8 +695,7 @@ export function doClaimSearch(
 }

 export function doRepost(options: StreamRepostOptions) {
-  return (dispatch: Dispatch) => {
-    // $FlowFixMe
+  return (dispatch: Dispatch): Promise<any> => {
    return new Promise(resolve => {
      dispatch({
        type: ACTIONS.CLAIM_REPOST_STARTED,
@ -677,6 +735,209 @@ export function doRepost(options: StreamRepostOptions) {
  };
 }

+export function doCollectionPublish(
+  options: {
+    name: string,
+    bid: string,
+    blocking: true,
+    title?: string,
+    channel_id?: string,
+    thumbnail_url?: string,
+    description?: string,
+    tags?: Array<Tag>,
+    languages?: Array<string>,
+    claims: Array<string>,
+  },
+  localId: string
+) {
+  return (dispatch: Dispatch): Promise<any> => {
+    // $FlowFixMe
+
+    const params: {
+      name: string,
+      bid: string,
+      channel_id?: string,
+      blocking?: true,
+      title?: string,
+      thumbnail_url?: string,
+      description?: string,
+      tags?: Array<string>,
+      languages?: Array<string>,
+      claims: Array<string>,
+    } = {
+      name: options.name,
+      bid: creditsToString(options.bid),
+      title: options.title,
+      thumbnail_url: options.thumbnail_url,
+      description: options.description,
+      tags: [],
+      languages: options.languages || [],
+      locations: [],
+      blocking: true,
+      claims: options.claims,
+    };
+
+    if (options.tags) {
+      params['tags'] = options.tags.map(tag => tag.name);
+    }
+
+    if (options.channel_id) {
+      params['channel_id'] = options.channel_id;
+    }
+
+    return new Promise(resolve => {
+      dispatch({
+        type: ACTIONS.COLLECTION_PUBLISH_STARTED,
+      });
+
+      function success(response) {
+        const collectionClaim = response.outputs[0];
+        dispatch(
+          batchActions(
+            {
+              type: ACTIONS.COLLECTION_PUBLISH_COMPLETED,
+              data: { claimId: collectionClaim.claim_id },
+            },
+            // move unpublished collection to pending collection with new publish id
+            // recent publish won't resolve this second. handle it in checkPending
+            {
+              type: ACTIONS.UPDATE_PENDING_CLAIMS,
+              data: {
+                claims: [collectionClaim],
+              },
+            }
+          )
+        );
+        dispatch({
+          type: ACTIONS.COLLECTION_PENDING,
+          data: { localId: localId, claimId: collectionClaim.claim_id },
+        });
+        dispatch(doCheckPendingClaims());
+        dispatch(doFetchCollectionListMine(1, 10));
+        return resolve(collectionClaim);
+      }
+
+      function failure(error) {
+        dispatch({
+          type: ACTIONS.COLLECTION_PUBLISH_FAILED,
+          data: {
+            error: error.message,
+          },
+        });
+      }
+
+      return Lbry.collection_create(params).then(success, failure);
+    });
+  };
+}
+
+export function doCollectionPublishUpdate(
+  options: {
+    bid?: string,
+    blocking?: true,
+    title?: string,
+    thumbnail_url?: string,
+    description?: string,
+    claim_id: string,
+    tags?: Array<Tag>,
+    languages?: Array<string>,
+    claims?: Array<string>,
+    channel_id?: string,
+  },
+  isBackgroundUpdate?: boolean
+) {
+  return (dispatch: Dispatch, getState: GetState): Promise<any> => {
+    // TODO: implement one click update
+
+    const updateParams: {
+      bid?: string,
+      blocking?: true,
+      title?: string,
+      thumbnail_url?: string,
+      channel_id?: string,
+      description?: string,
+      claim_id: string,
+      tags?: Array<string>,
+      languages?: Array<string>,
+      claims?: Array<string>,
+      clear_claims: boolean,
+      replace?: boolean,
+    } = isBackgroundUpdate
+      ? {
+        blocking: true,
+        claim_id: options.claim_id,
+        clear_claims: true,
+      }
+      : {
+        bid: creditsToString(options.bid),
+        title: options.title,
+        thumbnail_url: options.thumbnail_url,
+        description: options.description,
+        tags: [],
+        languages: options.languages || [],
+        locations: [],
+        blocking: true,
+        claim_id: options.claim_id,
+        clear_claims: true,
+        replace: true,
+      };
+
+    if (isBackgroundUpdate && updateParams.claim_id) {
+      const state = getState();
+      updateParams['claims'] = makeSelectClaimIdsForCollectionId(updateParams.claim_id)(state);
+    } else if (options.claims) {
+      updateParams['claims'] = options.claims;
+    }
+
+    if (options.tags) {
+      updateParams['tags'] = options.tags.map(tag => tag.name);
+    }
+
+    if (options.channel_id) {
+      updateParams['channel_id'] = options.channel_id;
+    }
+
+    return new Promise(resolve => {
+      dispatch({
+        type: ACTIONS.COLLECTION_PUBLISH_UPDATE_STARTED,
+      });
+
+      function success(response) {
+        const collectionClaim = response.outputs[0];
+        dispatch({
+          type: ACTIONS.COLLECTION_PUBLISH_UPDATE_COMPLETED,
+          data: {
+            collectionClaim,
+          },
+        });
+        dispatch({
+          type: ACTIONS.COLLECTION_PENDING,
+          data: { claimId: collectionClaim.claim_id },
+        });
+        dispatch({
+          type: ACTIONS.UPDATE_PENDING_CLAIMS,
+          data: {
+            claims: [collectionClaim],
+          },
+        });
+        dispatch(doCheckPendingClaims());
+        return resolve(collectionClaim);
+      }
+
+      function failure(error) {
+        dispatch({
+          type: ACTIONS.COLLECTION_PUBLISH_UPDATE_FAILED,
+          data: {
+            error: error.message,
+          },
+        });
+      }
+
+      return Lbry.collection_update(updateParams).then(success, failure);
+    });
+  };
+}
+
 export function doCheckPublishNameAvailability(name: string) {
  return (dispatch: Dispatch) => {
    dispatch({
@ -739,47 +1000,71 @@ export function doPurchaseList(page: number = 1, pageSize: number = PAGE_SIZE) {
  };
 }

-export const doCheckPendingClaims = (onConfirmed: Function) => (
+export const doCheckPendingClaims = (onChannelConfirmed: Function) => (
  dispatch: Dispatch,
  getState: GetState
 ) => {
-  let claimCheckInterval;
-
-  const checkClaimList = () => {
+  if (onChannelConfirmed) {
+    onChannelConfirmCallback = onChannelConfirmed;
+  }
+  clearInterval(checkPendingInterval);
+  const checkTxoList = () => {
    const state = getState();
-    const pendingIdSet = new Set(selectPendingIds(state));
-    Lbry.claim_list({ page: 1, page_size: 10 })
-      .then(result => {
-        const claims = result.items;
-        const claimsToConfirm = [];
-        claims.forEach(claim => {
-          const { claim_id: claimId } = claim;
-          if (claim.confirmations > 0 && pendingIdSet.has(claimId)) {
-            pendingIdSet.delete(claimId);
-            claimsToConfirm.push(claim);
-            if (onConfirmed) {
-              onConfirmed(claim);
+    const pendingById = Object.assign({}, selectPendingClaimsById(state));
+    const pendingTxos = (Object.values(pendingById): any).map(p => p.txid);
+    // use collections
+    const pendingCollections = selectPendingCollections(state);
+    if (pendingTxos.length) {
+      Lbry.txo_list({ txid: pendingTxos })
+        .then(result => {
+          const txos = result.items;
+          const idsToConfirm = [];
+          txos.forEach(txo => {
+            if (txo.claim_id && txo.confirmations > 0) {
+              idsToConfirm.push(txo.claim_id);
+              delete pendingById[txo.claim_id];
            }
+          });
+          return { idsToConfirm, pendingById };
+        })
+        .then(results => {
+          const { idsToConfirm, pendingById } = results;
+          if (idsToConfirm.length) {
+            return Lbry.claim_list({ claim_id: idsToConfirm, resolve: true }).then(results => {
+              const claims = results.items;
+              const collectionIds = claims
+                .filter(c => c.value_type === 'collection')
+                .map(c => c.claim_id);
+              dispatch({
+                type: ACTIONS.UPDATE_CONFIRMED_CLAIMS,
+                data: {
+                  claims: claims,
+                  pending: pendingById,
+                },
+              });
+              if (collectionIds.length) {
+                dispatch(
+                  doFetchItemsInCollections({
+                    collectionIds,
+                  })
+                );
+              }
+              const channelClaims = claims.filter(claim => claim.value_type === 'channel');
+              if (channelClaims.length && onChannelConfirmCallback) {
+                channelClaims.forEach(claim => onChannelConfirmCallback(claim));
+              }
+              if (Object.keys(pendingById).length === 0) {
+                clearInterval(checkPendingInterval);
+              }
+            });
          }
        });
-        if (claimsToConfirm.length) {
-          dispatch({
-            type: ACTIONS.UPDATE_CONFIRMED_CLAIMS,
-            data: {
-              claims: claimsToConfirm,
-            },
-          });
-        }
-        return pendingIdSet.size;
-      })
-      .then(len => {
-        if (!len) {
-          clearInterval(claimCheckInterval);
-        }
-      });
+    } else {
+      clearInterval(checkPendingInterval);
+    }
  };
-
-  claimCheckInterval = setInterval(() => {
-    checkClaimList();
+  // do something with onConfirmed (typically get blocklist for channel)
+  checkPendingInterval = setInterval(() => {
+    checkTxoList();
  }, 30000);
 };
--- a/src/redux/actions/collections.js
+++ b/src/redux/actions/collections.js
@ -0,0 +1,495 @@
+// @flow
+import * as ACTIONS from 'constants/action_types';
+import { v4 as uuid } from 'uuid';
+import Lbry from 'lbry';
+import { doClaimSearch, doAbandonClaim } from 'redux/actions/claims';
+import { makeSelectClaimForClaimId } from 'redux/selectors/claims';
+import {
+  makeSelectCollectionForId,
+  // makeSelectPublishedCollectionForId, // for "save" or "copy" action
+  makeSelectMyPublishedCollectionForId,
+  makeSelectPublishedCollectionForId,
+  makeSelectUnpublishedCollectionForId,
+  makeSelectEditedCollectionForId,
+} from 'redux/selectors/collections';
+import * as COLS from 'constants/collections';
+
+const getTimestamp = () => {
+  return Math.floor(Date.now() / 1000);
+};
+
+const FETCH_BATCH_SIZE = 50;
+
+export const doLocalCollectionCreate = (
+  name: string,
+  collectionItems: Array<string>,
+  type: string,
+  sourceId: string
+) => (dispatch: Dispatch) => {
+  return dispatch({
+    type: ACTIONS.COLLECTION_NEW,
+    data: {
+      entry: {
+        id: uuid(), // start with a uuid, this becomes a claimId after publish
+        name: name,
+        updatedAt: getTimestamp(),
+        items: collectionItems || [],
+        sourceId: sourceId,
+        type: type,
+      },
+    },
+  });
+};
+
+export const doCollectionDelete = (id: string, colKey: ?string = undefined) => (
+  dispatch: Dispatch,
+  getState: GetState
+) => {
+  const state = getState();
+  const claim = makeSelectClaimForClaimId(id)(state);
+  const collectionDelete = () =>
+    dispatch({
+      type: ACTIONS.COLLECTION_DELETE,
+      data: {
+        id: id,
+        collectionKey: colKey,
+      },
+    });
+  if (claim && !colKey) {
+    // could support "abandon, but keep" later
+    const { txid, nout } = claim;
+    return dispatch(doAbandonClaim(txid, nout, collectionDelete));
+  }
+  return collectionDelete();
+};
+
+// Given a collection, save its collectionId to be resolved and displayed in Library
+// export const doCollectionSave = (
+//   id: string,
+// ) => (dispatch: Dispatch) => {
+//   return dispatch({
+//     type: ACTIONS.COLLECTION_SAVE,
+//     data: {
+//       id: id,
+//     },
+//   });
+// };
+
+// Given a collection and name, copy it to a local private collection with a name
+// export const doCollectionCopy = (
+//   id: string,
+// ) => (dispatch: Dispatch) => {
+//   return dispatch({
+//     type: ACTIONS.COLLECTION_COPY,
+//     data: {
+//       id: id,
+//     },
+//   });
+// };
+
+export const doFetchItemsInCollections = (
+  resolveItemsOptions: {
+    collectionIds: Array<string>,
+    pageSize?: number,
+  },
+  resolveStartedCallback?: () => void
+) => async(dispatch: Dispatch, getState: GetState) => {
+  /*
+  1) make sure all the collection claims are loaded into claims reducer, search/resolve if necessary.
+  2) get the item claims for each
+  3) format and make sure they're in the order as in the claim
+  4) Build the collection objects and update collections reducer
+  5) Update redux claims reducer
+   */
+  let state = getState();
+  const { collectionIds, pageSize } = resolveItemsOptions;
+
+  dispatch({
+    type: ACTIONS.COLLECTION_ITEMS_RESOLVE_STARTED,
+    data: { ids: collectionIds },
+  });
+
+  if (resolveStartedCallback) resolveStartedCallback();
+
+  const collectionIdsToSearch = collectionIds.filter(claimId => !state.claims.byId[claimId]);
+
+  if (collectionIdsToSearch.length) {
+    await dispatch(doClaimSearch({ claim_ids: collectionIdsToSearch, page: 1, page_size: 9999 }));
+  }
+
+  const stateAfterClaimSearch = getState();
+
+  async function fetchItemsForCollectionClaim(claim: CollectionClaim, pageSize?: number) {
+    const totalItems = claim.value.claims && claim.value.claims.length;
+    const claimId = claim.claim_id;
+    const itemOrder = claim.value.claims;
+
+    const sortResults = (items: Array<Claim>, claimList) => {
+      const newItems: Array<Claim> = [];
+      claimList.forEach(id => {
+        const index = items.findIndex(i => i.claim_id === id);
+        if (index >= 0) {
+          newItems.push(items[index]);
+        }
+      });
+      /*
+        This will return newItems[] of length less than total_items below
+        if one or more of the claims has been abandoned. That's ok for now.
+      */
+      return newItems;
+    };
+
+    const mergeBatches = (
+      arrayOfResults: Array<{ items: Array<Claim>, total_items: number }>,
+      claimList: Array<string>
+    ) => {
+      const mergedResults: { items: Array<Claim>, total_items: number } = {
+        items: [],
+        total_items: 0,
+      };
+      arrayOfResults.forEach(result => {
+        mergedResults.items = mergedResults.items.concat(result.items);
+        mergedResults.total_items = result.total_items;
+      });
+
+      mergedResults.items = sortResults(mergedResults.items, claimList);
+      return mergedResults;
+    };
+
+    try {
+      const batchSize = pageSize || FETCH_BATCH_SIZE;
+      const batches: Array<Promise<any>> = [];
+
+      for (let i = 0; i < Math.ceil(totalItems / batchSize); i++) {
+        batches[i] = Lbry.claim_search({
+          claim_ids: claim.value.claims,
+          page: i + 1,
+          page_size: batchSize,
+          no_totals: true,
+        });
+      }
+      const itemsInBatches = await Promise.all(batches);
+      const result = mergeBatches(itemsInBatches, itemOrder);
+
+      // $FlowFixMe
+      const itemsById: { claimId: string, items?: ?Array<GenericClaim> } = { claimId: claimId };
+      if (result.items) {
+        itemsById.items = result.items;
+      } else {
+        itemsById.items = null;
+      }
+      return itemsById;
+    } catch (e) {
+      return {
+        claimId: claimId,
+        items: null,
+      };
+    }
+  }
+
+  function formatForClaimActions(resultClaimsByUri) {
+    const formattedClaims = {};
+    Object.entries(resultClaimsByUri).forEach(([uri, uriResolveInfo]) => {
+      // Flow has terrible Object.entries support
+      // https://github.com/facebook/flow/issues/2221
+      if (uriResolveInfo) {
+        let result = {};
+        if (uriResolveInfo.value_type === 'channel') {
+          result.channel = uriResolveInfo;
+          // $FlowFixMe
+          result.claimsInChannel = uriResolveInfo.meta.claims_in_channel;
+          // ALSO SKIP COLLECTIONS
+        } else if (uriResolveInfo.value_type === 'collection') {
+          result.collection = uriResolveInfo;
+        } else {
+          result.stream = uriResolveInfo;
+          if (uriResolveInfo.signing_channel) {
+            result.channel = uriResolveInfo.signing_channel;
+            result.claimsInChannel =
+              (uriResolveInfo.signing_channel.meta &&
+                uriResolveInfo.signing_channel.meta.claims_in_channel) ||
+              0;
+          }
+        }
+        // $FlowFixMe
+        formattedClaims[uri] = result;
+      }
+    });
+    return formattedClaims;
+  }
+
+  const invalidCollectionIds = [];
+  const promisedCollectionItemFetches = [];
+  collectionIds.forEach(collectionId => {
+    const claim = makeSelectClaimForClaimId(collectionId)(stateAfterClaimSearch);
+    if (!claim) {
+      invalidCollectionIds.push(collectionId);
+    } else {
+      promisedCollectionItemFetches.push(fetchItemsForCollectionClaim(claim, pageSize));
+    }
+  });
+
+  // $FlowFixMe
+  const collectionItemsById: Array<{
+    claimId: string,
+    items: ?Array<GenericClaim>,
+  }> = await Promise.all(promisedCollectionItemFetches);
+
+  const newCollectionObjectsById = {};
+  const resolvedItemsByUrl = {};
+  collectionItemsById.forEach(entry => {
+    // $FlowFixMe
+    const collectionItems: Array<any> = entry.items;
+    const collectionId = entry.claimId;
+    if (collectionItems) {
+      const claim = makeSelectClaimForClaimId(collectionId)(stateAfterClaimSearch);
+
+      const editedCollection = makeSelectEditedCollectionForId(collectionId)(stateAfterClaimSearch);
+      const { name, timestamp, value } = claim || {};
+      const { title } = value;
+      const valueTypes = new Set();
+      const streamTypes = new Set();
+
+      let newItems = [];
+      let isPlaylist;
+
+      if (collectionItems) {
+        collectionItems.forEach(collectionItem => {
+          newItems.push(collectionItem.permanent_url);
+          valueTypes.add(collectionItem.value_type);
+          if (collectionItem.value.stream_type) {
+            streamTypes.add(collectionItem.value.stream_type);
+          }
+          resolvedItemsByUrl[collectionItem.canonical_url] = collectionItem;
+        });
+        isPlaylist =
+          valueTypes.size === 1 &&
+          valueTypes.has('stream') &&
+          ((streamTypes.size === 1 && (streamTypes.has('audio') || streamTypes.has('video'))) ||
+            (streamTypes.size === 2 && (streamTypes.has('audio') && streamTypes.has('video'))));
+      }
+
+      newCollectionObjectsById[collectionId] = {
+        items: newItems,
+        id: collectionId,
+        name: title || name,
+        itemCount: claim.value.claims.length,
+        type: isPlaylist ? 'playlist' : 'collection',
+        updatedAt: timestamp,
+      };
+
+      if (editedCollection && timestamp > editedCollection['updatedAt']) {
+        dispatch({
+          type: ACTIONS.COLLECTION_DELETE,
+          data: {
+            id: collectionId,
+            collectionKey: 'edited',
+          },
+        });
+      }
+    } else {
+      invalidCollectionIds.push(collectionId);
+    }
+  });
+  const formattedClaimsByUri = formatForClaimActions(collectionItemsById);
+
+  dispatch({
+    type: ACTIONS.RESOLVE_URIS_COMPLETED,
+    data: { resolveInfo: formattedClaimsByUri },
+  });
+
+  dispatch({
+    type: ACTIONS.COLLECTION_ITEMS_RESOLVE_COMPLETED,
+    data: {
+      resolvedCollections: newCollectionObjectsById,
+      failedCollectionIds: invalidCollectionIds,
+    },
+  });
+};
+
+export const doFetchItemsInCollection = (
+  options: { collectionId: string, pageSize?: number },
+  cb?: () => void
+) => {
+  const { collectionId, pageSize } = options;
+  const newOptions: { collectionIds: Array<string>, pageSize?: number } = {
+    collectionIds: [collectionId],
+  };
+  if (pageSize) newOptions.pageSize = pageSize;
+  return doFetchItemsInCollections(newOptions, cb);
+};
+
+export const doCollectionEdit = (collectionId: string, params: CollectionEditParams) => async(
+  dispatch: Dispatch,
+  getState: GetState
+) => {
+  const state = getState();
+  const collection: Collection = makeSelectCollectionForId(collectionId)(state);
+  const editedCollection: Collection = makeSelectEditedCollectionForId(collectionId)(state);
+  const unpublishedCollection: Collection = makeSelectUnpublishedCollectionForId(collectionId)(
+    state
+  );
+  const publishedCollection: Collection = makeSelectPublishedCollectionForId(collectionId)(state); // needs to be published only
+
+  const generateCollectionItemsFromSearchResult = results => {
+    return (
+      Object.values(results)
+        // $FlowFixMe
+        .reduce(
+          (
+            acc,
+            cur: {
+              stream: ?StreamClaim,
+              channel: ?ChannelClaim,
+              claimsInChannel: ?number,
+              collection: ?CollectionClaim,
+            }
+          ) => {
+            let url;
+            if (cur.stream) {
+              url = cur.stream.permanent_url;
+            } else if (cur.channel) {
+              url = cur.channel.permanent_url;
+            } else if (cur.collection) {
+              url = cur.collection.permanent_url;
+            } else {
+              return acc;
+            }
+            acc.push(url);
+            return acc;
+          },
+          []
+        )
+    );
+  };
+
+  if (!collection) {
+    return dispatch({
+      type: ACTIONS.COLLECTION_ERROR,
+      data: {
+        message: 'collection does not exist',
+      },
+    });
+  }
+
+  let currentItems = collection.items ? collection.items.concat() : [];
+  const { claims: passedClaims, order, claimIds, replace, remove, type } = params;
+
+  const collectionType = type || collection.type;
+  let newItems: Array<?string> = currentItems;
+
+  if (passedClaims) {
+    if (remove) {
+      const passedUrls = passedClaims.map(claim => claim.permanent_url);
+      // $FlowFixMe // need this?
+      newItems = currentItems.filter((item: string) => !passedUrls.includes(item));
+    } else {
+      passedClaims.forEach(claim => newItems.push(claim.permanent_url));
+    }
+  }
+
+  if (claimIds) {
+    const batches = [];
+    if (claimIds.length > 50) {
+      for (let i = 0; i < Math.ceil(claimIds.length / 50); i++) {
+        batches[i] = claimIds.slice(i * 50, (i + 1) * 50);
+      }
+    } else {
+      batches[0] = claimIds;
+    }
+    const resultArray = await Promise.all(
+      batches.map(batch => {
+        let options = { claim_ids: batch, page: 1, page_size: 50 };
+        return dispatch(doClaimSearch(options));
+      })
+    );
+
+    const searchResults = Object.assign({}, ...resultArray);
+
+    if (replace) {
+      newItems = generateCollectionItemsFromSearchResult(searchResults);
+    } else {
+      newItems = currentItems.concat(generateCollectionItemsFromSearchResult(searchResults));
+    }
+  }
+
+  if (order) {
+    const [movedItem] = currentItems.splice(order.from, 1);
+    currentItems.splice(order.to, 0, movedItem);
+  }
+
+  // console.log('p&e', publishedCollection.items, newItems, publishedCollection.items.join(','), newItems.join(','))
+  if (editedCollection) {
+    // delete edited if newItems are the same as publishedItems
+    if (publishedCollection.items.join(',') === newItems.join(',')) {
+      dispatch({
+        type: ACTIONS.COLLECTION_DELETE,
+        data: {
+          id: collectionId,
+          collectionKey: 'edited',
+        },
+      });
+    } else {
+      dispatch({
+        type: ACTIONS.COLLECTION_EDIT,
+        data: {
+          id: collectionId,
+          collectionKey: 'edited',
+          collection: {
+            items: newItems,
+            id: collectionId,
+            name: params.name || collection.name,
+            updatedAt: getTimestamp(),
+            type: collectionType,
+          },
+        },
+      });
+    }
+  } else if (publishedCollection) {
+    dispatch({
+      type: ACTIONS.COLLECTION_EDIT,
+      data: {
+        id: collectionId,
+        collectionKey: 'edited',
+        collection: {
+          items: newItems,
+          id: collectionId,
+          name: params.name || collection.name,
+          updatedAt: getTimestamp(),
+          type: collectionType,
+        },
+      },
+    });
+  } else if (COLS.BUILTIN_LISTS.includes(collectionId)) {
+    dispatch({
+      type: ACTIONS.COLLECTION_EDIT,
+      data: {
+        id: collectionId,
+        collectionKey: 'builtin',
+        collection: {
+          items: newItems,
+          id: collectionId,
+          name: params.name || collection.name,
+          updatedAt: getTimestamp(),
+          type: collectionType,
+        },
+      },
+    });
+  } else if (unpublishedCollection) {
+    dispatch({
+      type: ACTIONS.COLLECTION_EDIT,
+      data: {
+        id: collectionId,
+        collectionKey: 'unpublished',
+        collection: {
+          items: newItems,
+          id: collectionId,
+          name: params.name || collection.name,
+          updatedAt: getTimestamp(),
+          type: collectionType,
+        },
+      },
+    });
+  }
+  return true;
+};
--- a/src/redux/actions/publish.js
+++ b/src/redux/actions/publish.js
@ -21,6 +21,7 @@ export const doResetThumbnailStatus = () => (dispatch: Dispatch) => {
    type: ACTIONS.UPDATE_PUBLISH_FORM,
    data: {
      thumbnailPath: '',
+      thumbnailError: undefined,
    },
  });

@ -68,7 +69,8 @@ export const doUploadThumbnail = (
  thumbnailBlob?: File,
  fsAdapter?: any,
  fs?: any,
-  path?: any
+  path?: any,
+  cb?: (string) => void
 ) => (dispatch: Dispatch) => {
  const downMessage = __('Thumbnail upload service may be down, try again later.');
  let thumbnail, fileExt, fileName, fileType;
@ -96,6 +98,13 @@ export const doUploadThumbnail = (
    );
  };

+  dispatch({
+    type: ACTIONS.UPDATE_PUBLISH_FORM,
+    data: {
+      thumbnailError: undefined,
+    },
+  });
+
  const doUpload = data => {
    return fetch(SPEECH_PUBLISH, {
      method: 'POST',
@ -104,15 +113,17 @@ export const doUploadThumbnail = (
      .then(res => res.text())
      .then(text => (text.length ? JSON.parse(text) : {}))
      .then(json => {
-        return json.success
-          ? dispatch({
-              type: ACTIONS.UPDATE_PUBLISH_FORM,
-              data: {
-                uploadThumbnailStatus: THUMBNAIL_STATUSES.COMPLETE,
-                thumbnail: json.data.serveUrl,
-              },
-            })
-          : uploadError(json.message || downMessage);
+        if (!json.success) return uploadError(json.message || downMessage);
+        if (cb) {
+          cb(json.data.serveUrl);
+        }
+        return dispatch({
+          type: ACTIONS.UPDATE_PUBLISH_FORM,
+          data: {
+            uploadThumbnailStatus: THUMBNAIL_STATUSES.COMPLETE,
+            thumbnail: json.data.serveUrl,
+          },
+        });
      })
      .catch(err => {
        let message = err.message;
@ -200,7 +211,8 @@ export const doPrepareEdit = (claim: StreamClaim, uri: string, fileInfo: FileLis
    description,
    fee,
    languages,
-    release_time: release_time ? Number(release_time) * 1000 : undefined,
+    releaseTime: release_time,
+    releaseTimeEdited: undefined,
    thumbnail: thumbnail ? thumbnail.url : null,
    title,
    uri,
@ -254,7 +266,7 @@ export const doPublish = (success: Function, fail: Function, preview: Function)
    filePath,
    description,
    language,
-    releaseTime,
+    releaseTimeEdited,
    license,
    licenseUrl,
    useLBRYUploader,
@ -347,8 +359,8 @@ export const doPublish = (success: Function, fail: Function, preview: Function)
  }

  // Set release time to curret date. On edits, keep original release/transaction time as release_time
-  if (releaseTime) {
-    publishPayload.release_time = Number(Math.round(new Date(releaseTime) / 1000));
+  if (releaseTimeEdited) {
+    publishPayload.release_time = releaseTimeEdited;
  } else if (myClaimForUriEditing && myClaimForUriEditing.value.release_time) {
    publishPayload.release_time = Number(myClaimForUri.value.release_time);
  } else if (myClaimForUriEditing && myClaimForUriEditing.timestamp) {
--- a/src/redux/actions/sync.js
+++ b/src/redux/actions/sync.js
@ -13,6 +13,10 @@ type SharedData = {
    settings?: any,
    app_welcome_version?: number,
    sharing_3P?: boolean,
+    unpublishedCollections: CollectionGroup,
+    editedCollections: CollectionGroup,
+    builtinCollections: CollectionGroup,
+    savedCollections: Array<string>,
  },
 };

@ -27,6 +31,10 @@ function extractUserState(rawObj: SharedData) {
      settings,
      app_welcome_version,
      sharing_3P,
+      unpublishedCollections,
+      editedCollections,
+      builtinCollections,
+      savedCollections,
    } = rawObj.value;

    return {
@ -38,6 +46,10 @@ function extractUserState(rawObj: SharedData) {
      ...(settings ? { settings } : {}),
      ...(app_welcome_version ? { app_welcome_version } : {}),
      ...(sharing_3P ? { sharing_3P } : {}),
+      ...(unpublishedCollections ? { unpublishedCollections } : {}),
+      ...(editedCollections ? { editedCollections } : {}),
+      ...(builtinCollections ? { builtinCollections } : {}),
+      ...(savedCollections ? { savedCollections } : {}),
    };
  }

@ -55,6 +67,10 @@ export function doPopulateSharedUserState(sharedSettings: any) {
      settings,
      app_welcome_version,
      sharing_3P,
+      unpublishedCollections,
+      editedCollections,
+      builtinCollections,
+      savedCollections,
    } = extractUserState(sharedSettings);
    dispatch({
      type: ACTIONS.USER_STATE_POPULATE,
@ -67,6 +83,10 @@ export function doPopulateSharedUserState(sharedSettings: any) {
        settings,
        welcomeVersion: app_welcome_version,
        allowAnalytics: sharing_3P,
+        unpublishedCollections,
+        editedCollections,
+        builtinCollections,
+        savedCollections,
      },
    });
  };
--- a/src/redux/actions/wallet.js
+++ b/src/redux/actions/wallet.js
@ -61,9 +61,8 @@ export function doBalanceSubscribe() {
  };
 }

-export function doFetchTransactions(page = 1, pageSize = 99999) {
+export function doFetchTransactions(page = 1, pageSize = 999999) {
  return dispatch => {
-    dispatch(doFetchSupports());
    dispatch({
      type: ACTIONS.FETCH_TRANSACTIONS_STARTED,
    });
@ -349,7 +348,7 @@ export function doSetDraftTransactionAddress(address) {
  };
 }

-export function doSendTip(params, isSupport, successCallback, errorCallback) {
+export function doSendTip(params, isSupport, successCallback, errorCallback, shouldNotify = true) {
  return (dispatch, getState) => {
    const state = getState();
    const balance = selectBalance(state);
@ -368,23 +367,25 @@ export function doSendTip(params, isSupport, successCallback, errorCallback) {
      return;
    }

-    const success = () => {
-      dispatch(
-        doToast({
-          message: shouldSupport
-            ? __('You deposited %amount% LBRY Credits as a support!', { amount: params.amount })
-            : __('You sent %amount% LBRY Credits as a tip, Mahalo!', { amount: params.amount }),
-          linkText: __('History'),
-          linkTarget: '/wallet',
-        })
-      );
+    const success = response => {
+      if (shouldNotify) {
+        dispatch(
+          doToast({
+            message: shouldSupport
+              ? __('You deposited %amount% LBRY Credits as a support!', { amount: params.amount })
+              : __('You sent %amount% LBRY Credits as a tip, Mahalo!', { amount: params.amount }),
+            linkText: __('History'),
+            linkTarget: '/wallet',
+          })
+        );
+      }

      dispatch({
        type: ACTIONS.SUPPORT_TRANSACTION_COMPLETED,
      });

      if (successCallback) {
-        successCallback();
+        successCallback(response);
      }
    };

--- a/src/redux/middleware/shared-state.js
+++ b/src/redux/middleware/shared-state.js
@ -2,9 +2,10 @@
 import isEqual from 'util/deep-equal';
 import { doPreferenceSet } from 'redux/actions/sync';

+const RUN_PREFERENCES_DELAY_MS = 2000;
 const SHARED_PREFERENCE_VERSION = '0.1';
 let oldShared = {};
-
+let timeout;
 export const buildSharedStateMiddleware = (
  actions: Array<string>,
  sharedStateFilters: {},
@ -22,40 +23,43 @@ export const buildSharedStateMiddleware = (
  if (!actions.includes(action.type) || typeof action === 'function') {
    return next(action);
  }
-
+  clearTimeout(timeout);
  const actionResult = next(action);
  // Call `getState` after calling `next` to ensure the state has updated in response to the action
-  const nextState: { user: any, settings: any } = getState();
-  const syncEnabled =
-    nextState.settings &&
-    nextState.settings.clientSettings &&
-    nextState.settings.clientSettings.enable_sync;
-  const hasVerifiedEmail =
-    nextState.user && nextState.user.user && nextState.user.user.has_verified_email;
-  const preferenceKey = syncEnabled && hasVerifiedEmail ? 'shared' : 'local';
-  const shared = {};
+  function runPreferences() {
+    const nextState: { user: any, settings: any } = getState();
+    const syncEnabled =
+      nextState.settings &&
+      nextState.settings.clientSettings &&
+      nextState.settings.clientSettings.enable_sync;
+    const hasVerifiedEmail =
+      nextState.user && nextState.user.user && nextState.user.user.has_verified_email;
+    const preferenceKey = syncEnabled && hasVerifiedEmail ? 'shared' : 'local';
+    const shared = {};

-  Object.keys(sharedStateFilters).forEach(key => {
-    const filter = sharedStateFilters[key];
-    const { source, property, transform } = filter;
-    let value = nextState[source][property];
-    if (transform) {
-      value = transform(value);
+    Object.keys(sharedStateFilters).forEach(key => {
+      const filter = sharedStateFilters[key];
+      const { source, property, transform } = filter;
+      let value = nextState[source][property];
+      if (transform) {
+        value = transform(value);
+      }
+
+      shared[key] = value;
+    });
+
+    if (!isEqual(oldShared, shared)) {
+      // only update if the preference changed from last call in the same session
+      oldShared = shared;
+      dispatch(doPreferenceSet(preferenceKey, shared, SHARED_PREFERENCE_VERSION));
    }

-    shared[key] = value;
-  });
-
-  if (!isEqual(oldShared, shared)) {
-    // only update if the preference changed from last call in the same session
-    oldShared = shared;
-    dispatch(doPreferenceSet(preferenceKey, shared, SHARED_PREFERENCE_VERSION));
+    if (sharedStateCb) {
+      // Pass dispatch to the callback to consumers can dispatch actions in response to preference set
+      sharedStateCb({ dispatch, getState });
+    }
+    clearTimeout(timeout);
+    return actionResult;
  }
-
-  if (sharedStateCb) {
-    // Pass dispatch to the callback to consumers can dispatch actions in response to preference set
-    sharedStateCb({ dispatch, getState });
-  }
-
-  return actionResult;
+  timeout = setTimeout(runPreferences, RUN_PREFERENCES_DELAY_MS);
 };
--- a/src/redux/reducers/claims.js
+++ b/src/redux/reducers/claims.js
@ -13,17 +13,20 @@ import mergeClaim from 'util/merge-claim';

 type State = {
  createChannelError: ?string,
+  createCollectionError: ?string,
  channelClaimCounts: { [string]: number },
  claimsByUri: { [string]: string },
  byId: { [string]: Claim },
+  pendingById: { [string]: Claim }, // keep pending claims
  resolvingUris: Array<string>,
-  pendingIds: Array<string>,
  reflectingById: { [string]: ReflectingUpdate },
  myClaims: ?Array<string>,
  myChannelClaims: ?Array<string>,
+  myCollectionClaims: ?Array<string>,
  abandoningById: { [string]: boolean },
  fetchingChannelClaims: { [string]: number },
  fetchingMyChannels: boolean,
+  fetchingMyCollections: boolean,
  fetchingClaimSearchByQuery: { [string]: boolean },
  purchaseUriSuccess: boolean,
  myPurchases: ?Array<string>,
@ -34,6 +37,7 @@ type State = {
  claimSearchByQuery: { [string]: Array<string> },
  claimSearchByQueryLastPageReached: { [string]: Array<boolean> },
  creatingChannel: boolean,
+  creatingCollection: boolean,
  paginatedClaimsByChannel: {
    [string]: {
      all: Array<string>,
@ -43,7 +47,9 @@ type State = {
    },
  },
  updateChannelError: ?string,
+  updateCollectionError: ?string,
  updatingChannel: boolean,
+  updatingCollection: boolean,
  pendingChannelImport: string | boolean,
  repostLoading: boolean,
  repostError: ?string,
@ -66,6 +72,7 @@ const defaultState = {
  fetchingChannelClaims: {},
  resolvingUris: [],
  myChannelClaims: undefined,
+  myCollectionClaims: [],
  myClaims: undefined,
  myPurchases: undefined,
  myPurchasesPageNumber: undefined,
@ -74,17 +81,22 @@ const defaultState = {
  fetchingMyPurchases: false,
  fetchingMyPurchasesError: undefined,
  fetchingMyChannels: false,
+  fetchingMyCollections: false,
  abandoningById: {},
-  pendingIds: [],
+  pendingById: {},
  reflectingById: {},
  claimSearchError: false,
  claimSearchByQuery: {},
  claimSearchByQueryLastPageReached: {},
  fetchingClaimSearchByQuery: {},
  updateChannelError: '',
+  updateCollectionError: '',
  updatingChannel: false,
  creatingChannel: false,
  createChannelError: undefined,
+  updatingCollection: false,
+  creatingCollection: false,
+  createCollectionError: undefined,
  pendingChannelImport: false,
  repostLoading: false,
  repostError: undefined,
@ -100,30 +112,22 @@ const defaultState = {
 };

 function handleClaimAction(state: State, action: any): State {
-  const {
-    resolveInfo,
-  }: {
-    [string]: {
-      stream: ?StreamClaim,
-      channel: ?ChannelClaim,
-      claimsInChannel: ?number,
-    },
-  } = action.data;
+  const { resolveInfo }: ClaimActionResolveInfo = action.data;

  const byUri = Object.assign({}, state.claimsByUri);
  const byId = Object.assign({}, state.byId);
  const channelClaimCounts = Object.assign({}, state.channelClaimCounts);
-  const pendingIds = state.pendingIds;
+  const pendingById = state.pendingById;
  let newResolvingUrls = new Set(state.resolvingUris);
  let myClaimIds = new Set(state.myClaims);

  Object.entries(resolveInfo).forEach(([url: string, resolveResponse: ResolveResponse]) => {
    // $FlowFixMe
-    const { claimsInChannel, stream, channel: channelFromResolve } = resolveResponse;
+    const { claimsInChannel, stream, channel: channelFromResolve, collection } = resolveResponse;
    const channel = channelFromResolve || (stream && stream.signing_channel);

    if (stream) {
-      if (pendingIds.includes(stream.claim_id)) {
+      if (pendingById[stream.claim_id]) {
        byId[stream.claim_id] = mergeClaim(stream, byId[stream.claim_id]);
      } else {
        byId[stream.claim_id] = stream;
@ -153,20 +157,37 @@ function handleClaimAction(state: State, action: any): State {
        channelClaimCounts[channel.canonical_url] = claimsInChannel;
      }

-      if (pendingIds.includes(channel.claim_id)) {
+      if (pendingById[channel.claim_id]) {
        byId[channel.claim_id] = mergeClaim(channel, byId[channel.claim_id]);
      } else {
        byId[channel.claim_id] = channel;
      }
-      // Also add the permanent_url here until lighthouse returns canonical_url for search results
+
      byUri[channel.permanent_url] = channel.claim_id;
      byUri[channel.canonical_url] = channel.claim_id;
      newResolvingUrls.delete(channel.canonical_url);
      newResolvingUrls.delete(channel.permanent_url);
    }

+    if (collection) {
+      if (pendingById[collection.claim_id]) {
+        byId[collection.claim_id] = mergeClaim(collection, byId[collection.claim_id]);
+      } else {
+        byId[collection.claim_id] = collection;
+      }
+      byUri[url] = collection.claim_id;
+      byUri[collection.canonical_url] = collection.claim_id;
+      byUri[collection.permanent_url] = collection.claim_id;
+      newResolvingUrls.delete(collection.canonical_url);
+      newResolvingUrls.delete(collection.permanent_url);
+
+      if (collection.is_my_output) {
+        myClaimIds.add(collection.claim_id);
+      }
+    }
+
    newResolvingUrls.delete(url);
-    if (!stream && !channel && !pendingIds.includes(byUri[url])) {
+    if (!stream && !channel && !collection && !pendingById[byUri[url]]) {
      byUri[url] = null;
    }
  });
@ -209,34 +230,33 @@ reducers[ACTIONS.FETCH_CLAIM_LIST_MINE_STARTED] = (state: State): State =>
  });

 reducers[ACTIONS.FETCH_CLAIM_LIST_MINE_COMPLETED] = (state: State, action: any): State => {
-  const { result, resolve }: { result: ClaimListResponse, resolve: boolean } = action.data;
+  const { result }: { result: ClaimListResponse } = action.data;
  const claims = result.items;
  const page = result.page;
  const totalItems = result.total_items;

  const byId = Object.assign({}, state.byId);
  const byUri = Object.assign({}, state.claimsByUri);
-  const pendingIds = state.pendingIds || [];
+  const pendingById = Object.assign({}, state.pendingById);
  let myClaimIds = new Set(state.myClaims);
  let urlsForCurrentPage = [];

-  const pendingIdSet = new Set(pendingIds);
-
  claims.forEach((claim: Claim) => {
-    const { permanent_url: permanentUri, claim_id: claimId } = claim;
+    const { permanent_url: permanentUri, claim_id: claimId, canonical_url: canonicalUri } = claim;
    if (claim.type && claim.type.match(/claim|update/)) {
      urlsForCurrentPage.push(permanentUri);
      if (claim.confirmations < 1) {
-        pendingIdSet.add(claimId);
-      } else if (!resolve && pendingIdSet.has(claimId) && claim.confirmations > 0) {
-        pendingIdSet.delete(claimId);
-      }
-      if (pendingIds.includes(claimId)) {
-        byId[claimId] = mergeClaim(claim, byId[claimId]);
+        pendingById[claimId] = claim;
+        if (byId[claimId]) {
+          byId[claimId] = mergeClaim(claim, byId[claimId]);
+        } else {
+          byId[claimId] = claim;
+        }
      } else {
        byId[claimId] = claim;
      }
      byUri[permanentUri] = claimId;
+      byUri[canonicalUri] = claimId;
      myClaimIds.add(claimId);
    }
  });
@ -245,7 +265,7 @@ reducers[ACTIONS.FETCH_CLAIM_LIST_MINE_COMPLETED] = (state: State, action: any):
    isFetchingClaimListMine: false,
    myClaims: Array.from(myClaimIds),
    byId,
-    pendingIds: Array.from(pendingIdSet),
+    pendingById,
    claimsByUri: byUri,
    myClaimsPageResults: urlsForCurrentPage,
    myClaimsPageNumber: page,
@ -258,9 +278,8 @@ reducers[ACTIONS.FETCH_CHANNEL_LIST_STARTED] = (state: State): State =>

 reducers[ACTIONS.FETCH_CHANNEL_LIST_COMPLETED] = (state: State, action: any): State => {
  const { claims }: { claims: Array<ChannelClaim> } = action.data;
-  const myClaims = state.myClaims || [];
  let myClaimIds = new Set(state.myClaims);
-  const pendingIds = state.pendingIds || [];
+  const pendingById = Object.assign({}, state.pendingById);
  let myChannelClaims;
  const byId = Object.assign({}, state.byId);
  const byUri = Object.assign({}, state.claimsByUri);
@ -274,7 +293,12 @@ reducers[ACTIONS.FETCH_CHANNEL_LIST_COMPLETED] = (state: State, action: any): St
    claims.forEach(claim => {
      const { meta } = claim;
      const { claims_in_channel: claimsInChannel } = claim.meta;
-      const { canonical_url: canonicalUrl, permanent_url: permanentUrl, claim_id: claimId } = claim;
+      const {
+        canonical_url: canonicalUrl,
+        permanent_url: permanentUrl,
+        claim_id: claimId,
+        confirmations,
+      } = claim;

      byUri[canonicalUrl] = claimId;
      byUri[permanentUrl] = claimId;
@ -283,7 +307,14 @@ reducers[ACTIONS.FETCH_CHANNEL_LIST_COMPLETED] = (state: State, action: any): St

      // $FlowFixMe
      myChannelClaims.add(claimId);
-      if (!pendingIds.some(c => c === claimId)) {
+      if (confirmations < 1) {
+        pendingById[claimId] = claim;
+        if (byId[claimId]) {
+          byId[claimId] = mergeClaim(claim, byId[claimId]);
+        } else {
+          byId[claimId] = claim;
+        }
+      } else {
        byId[claimId] = claim;
      }
      myClaimIds.add(claimId);
@ -292,6 +323,7 @@ reducers[ACTIONS.FETCH_CHANNEL_LIST_COMPLETED] = (state: State, action: any): St

  return Object.assign({}, state, {
    byId,
+    pendingById,
    claimsByUri: byUri,
    channelClaimCounts,
    fetchingMyChannels: false,
@ -306,6 +338,66 @@ reducers[ACTIONS.FETCH_CHANNEL_LIST_FAILED] = (state: State, action: any): State
  });
 };

+reducers[ACTIONS.FETCH_COLLECTION_LIST_STARTED] = (state: State): State => ({
+  ...state,
+  fetchingMyCollections: true,
+});
+
+reducers[ACTIONS.FETCH_COLLECTION_LIST_COMPLETED] = (state: State, action: any): State => {
+  const { claims }: { claims: Array<CollectionClaim> } = action.data;
+  const myClaims = state.myClaims || [];
+  let myClaimIds = new Set(myClaims);
+  const pendingById = Object.assign({}, state.pendingById);
+  let myCollectionClaimsSet = new Set([]);
+  const byId = Object.assign({}, state.byId);
+  const byUri = Object.assign({}, state.claimsByUri);
+
+  if (claims.length) {
+    myCollectionClaimsSet = new Set(state.myCollectionClaims);
+    claims.forEach(claim => {
+      const { meta } = claim;
+      const {
+        canonical_url: canonicalUrl,
+        permanent_url: permanentUrl,
+        claim_id: claimId,
+        confirmations,
+      } = claim;
+
+      byUri[canonicalUrl] = claimId;
+      byUri[permanentUrl] = claimId;
+
+      // $FlowFixMe
+      myCollectionClaimsSet.add(claimId);
+      // we don't want to overwrite a pending result with a resolve
+      if (confirmations < 1) {
+        pendingById[claimId] = claim;
+        if (byId[claimId]) {
+          byId[claimId] = mergeClaim(claim, byId[claimId]);
+        } else {
+          byId[claimId] = claim;
+        }
+      } else {
+        byId[claimId] = claim;
+      }
+      myClaimIds.add(claimId);
+    });
+  }
+
+  return {
+    ...state,
+    byId,
+    pendingById,
+    claimsByUri: byUri,
+    fetchingMyCollections: false,
+    myCollectionClaims: Array.from(myCollectionClaimsSet),
+    myClaims: myClaimIds ? Array.from(myClaimIds) : null,
+  };
+};
+
+reducers[ACTIONS.FETCH_COLLECTION_LIST_FAILED] = (state: State): State => {
+  return { ...state, fetchingMyCollections: false };
+};
+
 reducers[ACTIONS.FETCH_CHANNEL_CLAIMS_STARTED] = (state: State, action: any): State => {
  const { uri, page } = action.data;
  const fetchingChannelClaims = Object.assign({}, state.fetchingChannelClaims);
@ -387,9 +479,8 @@ reducers[ACTIONS.ABANDON_CLAIM_STARTED] = (state: State, action: any): State =>
 reducers[ACTIONS.UPDATE_PENDING_CLAIMS] = (state: State, action: any): State => {
  const { claims: pendingClaims }: { claims: Array<Claim> } = action.data;
  const byId = Object.assign({}, state.byId);
+  const pendingById = Object.assign({}, state.pendingById);
  const byUri = Object.assign({}, state.claimsByUri);
-  const pendingIds = state.pendingIds;
-  const pendingIdSet = new Set(pendingIds);
  let myClaimIds = new Set(state.myClaims);
  const myChannelClaims = new Set(state.myChannelClaims);

@ -397,7 +488,7 @@ reducers[ACTIONS.UPDATE_PENDING_CLAIMS] = (state: State, action: any): State =>
  pendingClaims.forEach((claim: Claim) => {
    let newClaim;
    const { permanent_url: uri, claim_id: claimId, type, value_type: valueType } = claim;
-    pendingIdSet.add(claimId);
+    pendingById[claimId] = claim; // make sure we don't need to merge?
    const oldClaim = byId[claimId];
    if (oldClaim && oldClaim.canonical_url) {
      newClaim = mergeClaim(oldClaim, claim);
@ -417,21 +508,22 @@ reducers[ACTIONS.UPDATE_PENDING_CLAIMS] = (state: State, action: any): State =>
  return Object.assign({}, state, {
    myClaims: Array.from(myClaimIds),
    byId,
+    pendingById,
    myChannelClaims: Array.from(myChannelClaims),
    claimsByUri: byUri,
-    pendingIds: Array.from(pendingIdSet),
  });
 };

 reducers[ACTIONS.UPDATE_CONFIRMED_CLAIMS] = (state: State, action: any): State => {
-  const { claims: confirmedClaims }: { claims: Array<Claim> } = action.data;
+  const {
+    claims: confirmedClaims,
+    pending: pendingClaims,
+  }: { claims: Array<Claim>, pending: { [string]: Claim } } = action.data;
  const byId = Object.assign({}, state.byId);
  const byUri = Object.assign({}, state.claimsByUri);
-  const pendingIds = state.pendingIds;
-  const pendingIdSet = new Set(pendingIds);
-
+  //
  confirmedClaims.forEach((claim: GenericClaim) => {
-    const { permanent_url: permanentUri, claim_id: claimId, type } = claim;
+    const { claim_id: claimId, type } = claim;
    let newClaim = claim;
    const oldClaim = byId[claimId];
    if (oldClaim && oldClaim.canonical_url) {
@ -439,11 +531,10 @@ reducers[ACTIONS.UPDATE_CONFIRMED_CLAIMS] = (state: State, action: any): State =
    }
    if (type && type.match(/claim|update|channel/)) {
      byId[claimId] = newClaim;
-      pendingIdSet.delete(claimId);
    }
  });
  return Object.assign({}, state, {
-    pendingIds: Array.from(pendingIdSet),
+    pendingById: pendingClaims,
    byId,
    claimsByUri: byUri,
  });
@ -455,6 +546,7 @@ reducers[ACTIONS.ABANDON_CLAIM_SUCCEEDED] = (state: State, action: any): State =
  const newMyClaims = state.myClaims ? state.myClaims.slice() : [];
  const newMyChannelClaims = state.myChannelClaims ? state.myChannelClaims.slice() : [];
  const claimsByUri = Object.assign({}, state.claimsByUri);
+  const newMyCollectionClaims = state.myCollectionClaims ? state.myCollectionClaims.slice() : [];

  Object.keys(claimsByUri).forEach(uri => {
    if (claimsByUri[uri] === claimId) {
@ -463,12 +555,14 @@ reducers[ACTIONS.ABANDON_CLAIM_SUCCEEDED] = (state: State, action: any): State =
  });
  const myClaims = newMyClaims.filter(i => i !== claimId);
  const myChannelClaims = newMyChannelClaims.filter(i => i !== claimId);
+  const myCollectionClaims = newMyCollectionClaims.filter(i => i !== claimId);

  delete byId[claimId];

  return Object.assign({}, state, {
    myClaims,
    myChannelClaims,
+    myCollectionClaims,
    byId,
    claimsByUri,
  });
@ -520,6 +614,61 @@ reducers[ACTIONS.UPDATE_CHANNEL_FAILED] = (state: State, action: any): State =>
  });
 };

+reducers[ACTIONS.CLEAR_COLLECTION_ERRORS] = (state: State): State => ({
+  ...state,
+  createCollectionError: null,
+  updateCollectionError: null,
+});
+
+reducers[ACTIONS.COLLECTION_PUBLISH_STARTED] = (state: State): State => ({
+  ...state,
+  creatingCollection: true,
+  createCollectionError: null,
+});
+
+reducers[ACTIONS.COLLECTION_PUBLISH_COMPLETED] = (state: State, action: any): State => {
+  const myCollections = state.myCollectionClaims || [];
+  const myClaims = state.myClaims || [];
+  const { claimId } = action.data;
+  let myClaimIds = new Set(myClaims);
+  let myCollectionClaimsSet = new Set(myCollections);
+  myClaimIds.add(claimId);
+  myCollectionClaimsSet.add(claimId);
+  return Object.assign({}, state, {
+    creatingCollection: false,
+    myClaims: Array.from(myClaimIds),
+    myCollectionClaims: Array.from(myCollectionClaimsSet),
+  });
+};
+
+reducers[ACTIONS.COLLECTION_PUBLISH_FAILED] = (state: State, action: any): State => {
+  return Object.assign({}, state, {
+    creatingCollection: false,
+    createCollectionError: action.data.error,
+  });
+};
+
+reducers[ACTIONS.COLLECTION_PUBLISH_UPDATE_STARTED] = (state: State, action: any): State => {
+  return Object.assign({}, state, {
+    updateCollectionError: '',
+    updatingCollection: true,
+  });
+};
+
+reducers[ACTIONS.COLLECTION_PUBLISH_UPDATE_COMPLETED] = (state: State, action: any): State => {
+  return Object.assign({}, state, {
+    updateCollectionError: '',
+    updatingCollection: false,
+  });
+};
+
+reducers[ACTIONS.COLLECTION_PUBLISH_UPDATE_FAILED] = (state: State, action: any): State => {
+  return Object.assign({}, state, {
+    updateCollectionError: action.data.error,
+    updatingCollection: false,
+  });
+};
+
 reducers[ACTIONS.IMPORT_CHANNEL_STARTED] = (state: State): State =>
  Object.assign({}, state, { pendingChannelImports: true });

--- a/src/redux/reducers/collections.js
+++ b/src/redux/reducers/collections.js
@ -0,0 +1,239 @@
+// @flow
+import { handleActions } from 'util/redux-utils';
+import * as ACTIONS from 'constants/action_types';
+import * as COLS from 'constants/collections';
+
+const getTimestamp = () => {
+  return Math.floor(Date.now() / 1000);
+};
+
+const defaultState: CollectionState = {
+  builtin: {
+    watchlater: {
+      items: [],
+      id: COLS.WATCH_LATER_ID,
+      name: 'Watch Later',
+      updatedAt: getTimestamp(),
+      type: COLS.COL_TYPE_PLAYLIST,
+    },
+    favorites: {
+      items: [],
+      id: COLS.FAVORITES_ID,
+      name: 'Favorites',
+      type: COLS.COL_TYPE_PLAYLIST,
+      updatedAt: getTimestamp(),
+    },
+  },
+  resolved: {},
+  unpublished: {}, // sync
+  edited: {},
+  pending: {},
+  saved: [],
+  isResolvingCollectionById: {},
+  error: null,
+};
+
+const collectionsReducer = handleActions(
+  {
+    [ACTIONS.COLLECTION_NEW]: (state, action) => {
+      const { entry: params } = action.data; // { id:, items: Array<string>}
+      // entry
+      const newListTemplate = {
+        id: params.id,
+        name: params.name,
+        items: [],
+        updatedAt: getTimestamp(),
+        type: params.type,
+      };
+
+      const newList = Object.assign({}, newListTemplate, { ...params });
+      const { unpublished: lists } = state;
+      const newLists = Object.assign({}, lists, { [params.id]: newList });
+
+      return {
+        ...state,
+        unpublished: newLists,
+      };
+    },
+
+    [ACTIONS.COLLECTION_DELETE]: (state, action) => {
+      const { id, collectionKey } = action.data;
+      const { edited: editList, unpublished: unpublishedList, pending: pendingList } = state;
+      const newEditList = Object.assign({}, editList);
+      const newUnpublishedList = Object.assign({}, unpublishedList);
+
+      const newPendingList = Object.assign({}, pendingList);
+
+      if (collectionKey && state[collectionKey] && state[collectionKey][id]) {
+        const newList = Object.assign({}, state[collectionKey]);
+        delete newList[id];
+        return {
+          ...state,
+          [collectionKey]: newList,
+        };
+      } else {
+        if (newEditList[id]) {
+          delete newEditList[id];
+        } else if (newUnpublishedList[id]) {
+          delete newUnpublishedList[id];
+        } else if (newPendingList[id]) {
+          delete newPendingList[id];
+        }
+      }
+      return {
+        ...state,
+        edited: newEditList,
+        unpublished: newUnpublishedList,
+        pending: newPendingList,
+      };
+    },
+
+    [ACTIONS.COLLECTION_PENDING]: (state, action) => {
+      const { localId, claimId } = action.data;
+      const {
+        resolved: resolvedList,
+        edited: editList,
+        unpublished: unpublishedList,
+        pending: pendingList,
+      } = state;
+
+      const newEditList = Object.assign({}, editList);
+      const newResolvedList = Object.assign({}, resolvedList);
+      const newUnpublishedList = Object.assign({}, unpublishedList);
+      const newPendingList = Object.assign({}, pendingList);
+
+      if (localId) {
+        // new publish
+        newPendingList[claimId] = Object.assign({}, newUnpublishedList[localId] || {});
+        delete newUnpublishedList[localId];
+      } else {
+        // edit update
+        newPendingList[claimId] = Object.assign(
+          {},
+          newEditList[claimId] || newResolvedList[claimId]
+        );
+        delete newEditList[claimId];
+      }
+
+      return {
+        ...state,
+        edited: newEditList,
+        unpublished: newUnpublishedList,
+        pending: newPendingList,
+      };
+    },
+
+    [ACTIONS.COLLECTION_EDIT]: (state, action) => {
+      const { id, collectionKey, collection } = action.data;
+
+      if (COLS.BUILTIN_LISTS.includes(id)) {
+        const { builtin: lists } = state;
+        return {
+          ...state,
+          [collectionKey]: { ...lists, [id]: collection },
+        };
+      }
+
+      if (collectionKey === 'edited') {
+        const { edited: lists } = state;
+        return {
+          ...state,
+          edited: { ...lists, [id]: collection },
+        };
+      }
+      const { unpublished: lists } = state;
+      return {
+        ...state,
+        unpublished: { ...lists, [id]: collection },
+      };
+    },
+
+    [ACTIONS.COLLECTION_ERROR]: (state, action) => {
+      return Object.assign({}, state, {
+        error: action.data.message,
+      });
+    },
+
+    [ACTIONS.COLLECTION_ITEMS_RESOLVE_STARTED]: (state, action) => {
+      const { ids } = action.data;
+      const { isResolvingCollectionById } = state;
+      const newResolving = Object.assign({}, isResolvingCollectionById);
+      ids.forEach(id => {
+        newResolving[id] = true;
+      });
+      return Object.assign({}, state, {
+        ...state,
+        error: '',
+        isResolvingCollectionById: newResolving,
+      });
+    },
+    [ACTIONS.USER_STATE_POPULATE]: (state, action) => {
+      const {
+        builtinCollections,
+        savedCollections,
+        unpublishedCollections,
+        editedCollections,
+      } = action.data;
+      return {
+        ...state,
+        edited: editedCollections || state.edited,
+        unpublished: unpublishedCollections || state.unpublished,
+        builtin: builtinCollections || state.builtin,
+        saved: savedCollections || state.saved,
+      };
+    },
+    [ACTIONS.COLLECTION_ITEMS_RESOLVE_COMPLETED]: (state, action) => {
+      const { resolvedCollections, failedCollectionIds } = action.data;
+      const { pending, edited, isResolvingCollectionById, resolved } = state;
+      const newPending = Object.assign({}, pending);
+      const newEdited = Object.assign({}, edited);
+      const newResolved = Object.assign({}, resolved, resolvedCollections);
+
+      const resolvedIds = Object.keys(resolvedCollections);
+      const newResolving = Object.assign({}, isResolvingCollectionById);
+      if (resolvedCollections && Object.keys(resolvedCollections).length) {
+        resolvedIds.forEach(resolvedId => {
+          if (newEdited[resolvedId]) {
+            if (newEdited[resolvedId]['updatedAt'] < resolvedCollections[resolvedId]['updatedAt']) {
+              delete newEdited[resolvedId];
+            }
+          }
+          delete newResolving[resolvedId];
+          if (newPending[resolvedId]) {
+            delete newPending[resolvedId];
+          }
+        });
+      }
+
+      if (failedCollectionIds && Object.keys(failedCollectionIds).length) {
+        failedCollectionIds.forEach(failedId => {
+          delete newResolving[failedId];
+        });
+      }
+
+      return Object.assign({}, state, {
+        ...state,
+        pending: newPending,
+        resolved: newResolved,
+        edited: newEdited,
+        isResolvingCollectionById: newResolving,
+      });
+    },
+    [ACTIONS.COLLECTION_ITEMS_RESOLVE_FAILED]: (state, action) => {
+      const { ids } = action.data;
+      const { isResolvingCollectionById } = state;
+      const newResolving = Object.assign({}, isResolvingCollectionById);
+      ids.forEach(id => {
+        delete newResolving[id];
+      });
+      return Object.assign({}, state, {
+        ...state,
+        isResolvingCollectionById: newResolving,
+        error: action.data.message,
+      });
+    },
+  },
+  defaultState
+);
+
+export { collectionsReducer };
--- a/src/redux/reducers/publish.js
+++ b/src/redux/reducers/publish.js
@ -22,9 +22,11 @@ type PublishState = {
  thumbnail_url: string,
  thumbnailPath: string,
  uploadThumbnailStatus: string,
+  thumbnailError: ?boolean,
  description: string,
  language: string,
-  releaseTime: ?string,
+  releaseTime: ?number,
+  releaseTimeEdited: ?number,
  channel: string,
  channelId: ?string,
  name: string,
@ -55,9 +57,11 @@ const defaultState: PublishState = {
  thumbnail_url: '',
  thumbnailPath: '',
  uploadThumbnailStatus: THUMBNAIL_STATUSES.API_DOWN,
+  thumbnailError: undefined,
  description: '',
  language: '',
  releaseTime: undefined,
+  releaseTimeEdited: undefined,
  nsfw: false,
  channel: CHANNEL_ANONYMOUS,
  channelId: '',
--- a/src/redux/selectors/claims.js
+++ b/src/redux/selectors/claims.js
@ -1,5 +1,5 @@
 // @flow
-import { normalizeURI, buildURI, parseURI } from 'lbryURI';
+import { normalizeURI, parseURI } from 'lbryURI';
 import { selectSupportsByOutpoint } from 'redux/selectors/wallet';
 import { createSelector } from 'reselect';
 import { isClaimNsfw, filterClaims } from 'util/claim';
@ -7,11 +7,24 @@ import * as CLAIM from 'constants/claim';

 const selectState = state => state.claims || {};

-export const selectClaimsById = createSelector(
+export const selectById = createSelector(
  selectState,
  state => state.byId || {}
 );

+export const selectPendingClaimsById = createSelector(
+  selectState,
+  state => state.pendingById || {}
+);
+
+export const selectClaimsById = createSelector(
+  selectById,
+  selectPendingClaimsById,
+  (byId, pendingById) => {
+    return Object.assign(byId, pendingById); // do I need merged to keep metadata?
+  }
+);
+
 export const selectClaimIdsByUri = createSelector(
  selectState,
  state => state.claimsByUri || {}
@ -72,29 +85,42 @@ export const selectAllClaimsByChannel = createSelector(

 export const selectPendingIds = createSelector(
  selectState,
-  state => state.pendingIds || []
+  state => Object.keys(state.pendingById) || []
 );

 export const selectPendingClaims = createSelector(
-  selectPendingIds,
-  selectClaimsById,
-  (pendingIds, byId) => pendingIds.map(id => byId[id])
+  selectPendingClaimsById,
+  pendingById => Object.values(pendingById)
 );

 export const makeSelectClaimIsPending = (uri: string) =>
  createSelector(
    selectClaimIdsByUri,
-    selectPendingIds,
-    (idsByUri, pendingIds) => {
+    selectPendingClaimsById,
+    (idsByUri, pendingById) => {
      const claimId = idsByUri[normalizeURI(uri)];

      if (claimId) {
-        return pendingIds.some(i => i === claimId);
+        return Boolean(pendingById[claimId]);
      }
      return false;
    }
  );

+export const makeSelectClaimIdIsPending = (claimId: string) =>
+  createSelector(
+    selectPendingClaimsById,
+    pendingById => {
+      return Boolean(pendingById[claimId]);
+    }
+  );
+
+export const makeSelectClaimIdForUri = (uri: string) =>
+  createSelector(
+    selectClaimIdsByUri,
+    claimIds => claimIds[uri]
+  );
+
 export const selectReflectingById = createSelector(
  selectState,
  state => state.reflectingById
@ -139,7 +165,7 @@ export const makeSelectClaimForUri = (uri: string, returnRepost: boolean = true)

          return {
            ...repostedClaim,
-            repost_url: uri,
+            repost_url: normalizeURI(uri),
            repost_channel_url: channelUrl,
            repost_bid_amount: claim && claim.meta && claim.meta.effective_amount,
          };
@ -273,8 +299,8 @@ export const makeSelectMyPurchasesForPage = (query: ?string, page: number = 1) =
      const end = Number(page) * Number(CLAIM.PAGE_SIZE);
      return matchingFileInfos && matchingFileInfos.length
        ? matchingFileInfos
-            .slice(start, end)
-            .map(fileInfo => fileInfo.canonical_url || fileInfo.permanent_url)
+          .slice(start, end)
+          .map(fileInfo => fileInfo.canonical_url || fileInfo.permanent_url)
        : [];
    }
  );
@ -312,6 +338,7 @@ export const makeSelectClaimsInChannelForPage = (uri: string, page?: number) =>
    }
  );

+// THIS IS LEFT OVER FROM ONE TAB CHANNEL_CONTENT
 export const makeSelectTotalClaimsInChannelSearch = (uri: string) =>
  createSelector(
    selectClaimsById,
@ -322,6 +349,7 @@ export const makeSelectTotalClaimsInChannelSearch = (uri: string) =>
    }
  );

+// THIS IS LEFT OVER FROM ONE_TAB CHANNEL CONTENT
 export const makeSelectTotalPagesInChannelSearch = (uri: string) =>
  createSelector(
    selectClaimsById,
@ -332,21 +360,6 @@ export const makeSelectTotalPagesInChannelSearch = (uri: string) =>
    }
  );

-export const makeSelectClaimsInChannelForCurrentPageState = (uri: string) =>
-  createSelector(
-    selectClaimsById,
-    selectAllClaimsByChannel,
-    selectCurrentChannelPage,
-    (byId, allClaims, page) => {
-      const byChannel = allClaims[uri] || {};
-      const claimIds = byChannel[page || 1];
-
-      if (!claimIds) return claimIds;
-
-      return claimIds.map(claimId => byId[claimId]);
-    }
-  );
-
 export const makeSelectMetadataForUri = (uri: string) =>
  createSelector(
    makeSelectClaimForUri(uri),
@ -380,8 +393,8 @@ export const makeSelectDateForUri = (uri: string) =>
        (claim.value.release_time
          ? claim.value.release_time * 1000
          : claim.meta && claim.meta.creation_timestamp
-          ? claim.meta.creation_timestamp * 1000
-          : null);
+            ? claim.meta.creation_timestamp * 1000
+            : null);
      if (!timestamp) {
        return undefined;
      }
@ -487,7 +500,9 @@ export const selectMyClaims = createSelector(
 export const selectMyClaimsWithoutChannels = createSelector(
  selectMyClaims,
  myClaims =>
-    myClaims.filter(claim => !claim.name.match(/^@/)).sort((a, b) => a.timestamp - b.timestamp)
+    myClaims
+      .filter(claim => claim && !claim.name.match(/^@/))
+      .sort((a, b) => a.timestamp - b.timestamp)
 );

 export const selectMyClaimUrisWithoutChannels = createSelector(
@ -531,6 +546,11 @@ export const selectFetchingMyChannels = createSelector(
  state => state.fetchingMyChannels
 );

+export const selectFetchingMyCollections = createSelector(
+  selectState,
+  state => state.fetchingMyCollections
+);
+
 export const selectMyChannelClaims = createSelector(
  selectState,
  selectClaimsById,
@ -557,6 +577,11 @@ export const selectMyChannelUrls = createSelector(
  claims => (claims ? claims.map(claim => claim.canonical_url || claim.permanent_url) : undefined)
 );

+export const selectMyCollectionIds = createSelector(
+  selectState,
+  state => state.myCollectionClaims
+);
+
 export const selectResolvingUris = createSelector(
  selectState,
  state => state.resolvingUris || []
@ -585,31 +610,18 @@ export const selectChannelClaimCounts = createSelector(

 export const makeSelectPendingClaimForUri = (uri: string) =>
  createSelector(
-    selectPendingIds,
-    selectClaimsById,
-    (pending, claims) => {
-      let validUri;
-      let uriIsChannel;
+    selectPendingClaimsById,
+    pendingById => {
      let uriStreamName;
      let uriChannelName;
      try {
-        ({
-          isChannel: uriIsChannel,
-          streamName: uriStreamName,
-          channelName: uriChannelName,
-        } = parseURI(uri));
-        validUri = true;
+        ({ streamName: uriStreamName, channelName: uriChannelName } = parseURI(uri));
      } catch (e) {
        return null;
      }
-      const pendingClaims = pending.map(id => claims[id]);
-      const matchingClaim = pendingClaims.find(claim => {
-        const { streamName, channelName, isChannel } = parseURI(claim.permanent_url);
-        if (isChannel) {
-          return channelName === uriChannelName;
-        } else {
-          return streamName === uriStreamName;
-        }
+      const pendingClaims = (Object.values(pendingById): any);
+      const matchingClaim = pendingClaims.find((claim: GenericClaim) => {
+        return claim.normalized_name === uriChannelName || claim.normalized_name === uriStreamName;
      });
      return matchingClaim || null;
    }
@ -618,13 +630,13 @@ export const makeSelectPendingClaimForUri = (uri: string) =>
 export const makeSelectTotalItemsForChannel = (uri: string) =>
  createSelector(
    selectChannelClaimCounts,
-    byUri => byUri && byUri[uri]
+    byUri => byUri && byUri[normalizeURI(uri)]
  );

 export const makeSelectTotalPagesForChannel = (uri: string, pageSize: number = 10) =>
  createSelector(
    selectChannelClaimCounts,
-    byUri => byUri && byUri[uri] && Math.ceil(byUri[uri] / pageSize)
+    byUri => byUri && byUri[uri] && Math.ceil(byUri[normalizeURI(uri)] / pageSize)
  );

 export const makeSelectNsfwCountFromUris = (uris: Array<string>) =>
@ -640,27 +652,6 @@ export const makeSelectNsfwCountFromUris = (uris: Array<string>) =>
      }, 0)
  );

-export const makeSelectNsfwCountForChannel = (uri: string) =>
-  createSelector(
-    selectClaimsById,
-    selectAllClaimsByChannel,
-    selectCurrentChannelPage,
-    (byId, allClaims, page) => {
-      const byChannel = allClaims[uri] || {};
-      const claimIds = byChannel[page || 1];
-
-      if (!claimIds) return 0;
-
-      return claimIds.reduce((acc, claimId) => {
-        const claim = byId[claimId];
-        if (isClaimNsfw(claim)) {
-          return acc + 1;
-        }
-        return acc;
-      }, 0);
-    }
-  );
-
 export const makeSelectOmittedCountForChannel = (uri: string) =>
  createSelector(
    makeSelectTotalItemsForChannel(uri),
@ -740,14 +731,6 @@ export const makeSelectTagsForUri = (uri: string) =>
    }
  );

-export const makeSelectChannelTagsForUri = (uri: string) =>
-  createSelector(
-    makeSelectMetadataForUri(uri),
-    (metadata: ?GenericMetadata) => {
-      return (metadata && metadata.tags) || [];
-    }
-  );
-
 export const selectFetchingClaimSearchByQuery = createSelector(
  selectState,
  state => state.fetchingClaimSearchByQuery || {}
@ -917,3 +900,23 @@ export const makeSelectStakedLevelForChannelUri = (uri: string) =>
      return level;
    }
  );
+
+export const selectUpdatingCollection = createSelector(
+  selectState,
+  state => state.updatingCollection
+);
+
+export const selectUpdateCollectionError = createSelector(
+  selectState,
+  state => state.updateCollectionError
+);
+
+export const selectCreatingCollection = createSelector(
+  selectState,
+  state => state.creatingCollection
+);
+
+export const selectCreateCollectionError = createSelector(
+  selectState,
+  state => state.createCollectionError
+);
--- a/src/redux/selectors/collections.js
+++ b/src/redux/selectors/collections.js
@ -0,0 +1,311 @@
+// @flow
+import fromEntries from '@ungap/from-entries';
+import { createSelector } from 'reselect';
+import {
+  selectMyCollectionIds,
+  makeSelectClaimForUri,
+  selectClaimsByUri,
+} from 'redux/selectors/claims';
+import { parseURI } from 'lbryURI';
+
+const selectState = (state: { collections: CollectionState }) => state.collections;
+
+export const selectSavedCollectionIds = createSelector(
+  selectState,
+  collectionState => collectionState.saved
+);
+
+export const selectBuiltinCollections = createSelector(
+  selectState,
+  state => state.builtin
+);
+export const selectResolvedCollections = createSelector(
+  selectState,
+  state => state.resolved
+);
+
+export const selectMyUnpublishedCollections = createSelector(
+  selectState,
+  state => state.unpublished
+);
+
+export const selectMyEditedCollections = createSelector(
+  selectState,
+  state => state.edited
+);
+
+export const selectPendingCollections = createSelector(
+  selectState,
+  state => state.pending
+);
+
+export const makeSelectEditedCollectionForId = (id: string) =>
+  createSelector(
+    selectMyEditedCollections,
+    eLists => eLists[id]
+  );
+
+export const makeSelectPendingCollectionForId = (id: string) =>
+  createSelector(
+    selectPendingCollections,
+    pending => pending[id]
+  );
+
+export const makeSelectPublishedCollectionForId = (id: string) =>
+  createSelector(
+    selectResolvedCollections,
+    rLists => rLists[id]
+  );
+
+export const makeSelectUnpublishedCollectionForId = (id: string) =>
+  createSelector(
+    selectMyUnpublishedCollections,
+    rLists => rLists[id]
+  );
+
+export const makeSelectCollectionIsMine = (id: string) =>
+  createSelector(
+    selectMyCollectionIds,
+    selectMyUnpublishedCollections,
+    selectBuiltinCollections,
+    (publicIds, privateIds, builtinIds) => {
+      return Boolean(publicIds.includes(id) || privateIds[id] || builtinIds[id]);
+    }
+  );
+
+export const selectMyPublishedCollections = createSelector(
+  selectResolvedCollections,
+  selectPendingCollections,
+  selectMyEditedCollections,
+  selectMyCollectionIds,
+  (resolved, pending, edited, myIds) => {
+    // all resolved in myIds, plus those in pending and edited
+    const myPublishedCollections = fromEntries(
+      Object.entries(pending).concat(
+        Object.entries(resolved).filter(
+          ([key, val]) =>
+            myIds.includes(key) &&
+            // $FlowFixMe
+            !pending[key]
+        )
+      )
+    );
+    // now add in edited:
+    Object.entries(edited).forEach(([id, item]) => {
+      myPublishedCollections[id] = item;
+    });
+    return myPublishedCollections;
+  }
+);
+
+export const selectMyPublishedMixedCollections = createSelector(
+  selectMyPublishedCollections,
+  published => {
+    const myCollections = fromEntries(
+      // $FlowFixMe
+      Object.entries(published).filter(([key, collection]) => {
+        // $FlowFixMe
+        return collection.type === 'collection';
+      })
+    );
+    return myCollections;
+  }
+);
+
+export const selectMyPublishedPlaylistCollections = createSelector(
+  selectMyPublishedCollections,
+  published => {
+    const myCollections = fromEntries(
+      // $FlowFixMe
+      Object.entries(published).filter(([key, collection]) => {
+        // $FlowFixMe
+        return collection.type === 'playlist';
+      })
+    );
+    return myCollections;
+  }
+);
+
+export const makeSelectMyPublishedCollectionForId = (id: string) =>
+  createSelector(
+    selectMyPublishedCollections,
+    myPublishedCollections => myPublishedCollections[id]
+  );
+
+// export const selectSavedCollections = createSelector(
+//   selectResolvedCollections,
+//   selectSavedCollectionIds,
+//   (resolved, myIds) => {
+//     const mySavedCollections = fromEntries(
+//       Object.entries(resolved).filter(([key, val]) => myIds.includes(key))
+//     );
+//     return mySavedCollections;
+//   }
+// );
+
+export const makeSelectIsResolvingCollectionForId = (id: string) =>
+  createSelector(
+    selectState,
+    state => {
+      return state.isResolvingCollectionById[id];
+    }
+  );
+
+export const makeSelectCollectionForId = (id: string) =>
+  createSelector(
+    selectBuiltinCollections,
+    selectResolvedCollections,
+    selectMyUnpublishedCollections,
+    selectMyEditedCollections,
+    selectPendingCollections,
+    (bLists, rLists, uLists, eLists, pLists) => {
+      const collection = bLists[id] || uLists[id] || eLists[id] || pLists[id] || rLists[id];
+      return collection;
+    }
+  );
+
+export const makeSelectClaimUrlInCollection = (url: string) =>
+  createSelector(
+    selectBuiltinCollections,
+    selectMyPublishedCollections,
+    selectMyUnpublishedCollections,
+    selectMyEditedCollections,
+    selectPendingCollections,
+    (bLists, myRLists, uLists, eLists, pLists) => {
+      const collections = [bLists, uLists, eLists, myRLists, pLists];
+      const itemsInCollections = [];
+      collections.map(list => {
+        Object.entries(list).forEach(([key, value]) => {
+          // $FlowFixMe
+          value.items.map(item => {
+            itemsInCollections.push(item);
+          });
+        });
+      });
+      return itemsInCollections.includes(url);
+    }
+  );
+
+export const makeSelectCollectionForIdHasClaimUrl = (id: string, url: string) =>
+  createSelector(
+    makeSelectCollectionForId(id),
+    collection => collection && collection.items.includes(url)
+  );
+
+export const makeSelectUrlsForCollectionId = (id: string) =>
+  createSelector(
+    makeSelectCollectionForId(id),
+    collection => collection && collection.items
+  );
+
+export const makeSelectClaimIdsForCollectionId = (id: string) =>
+  createSelector(
+    makeSelectCollectionForId(id),
+    collection => {
+      const items = (collection && collection.items) || [];
+      const ids = items.map(item => {
+        const { claimId } = parseURI(item);
+        return claimId;
+      });
+      return ids;
+    }
+  );
+
+export const makeSelectIndexForUrlInCollection = (url: string, id: string) =>
+  createSelector(
+    state => state.content.shuffleList,
+    makeSelectUrlsForCollectionId(id),
+    makeSelectClaimForUri(url),
+    (shuffleState, urls, claim) => {
+      const shuffleUrls = shuffleState && shuffleState.collectionId === id && shuffleState.newUrls;
+      const listUrls = shuffleUrls || urls;
+
+      const index = listUrls && listUrls.findIndex(u => u === url);
+      if (index > -1) {
+        return index;
+      } else if (claim) {
+        const index = listUrls && listUrls.findIndex(u => u === claim.permanent_url);
+        if (index > -1) return index;
+        return claim;
+      }
+      return null;
+    }
+  );
+
+export const makeSelectPreviousUrlForCollectionAndUrl = (id: string, url: string) =>
+  createSelector(
+    state => state.content.shuffleList,
+    state => state.content.loopList,
+    makeSelectIndexForUrlInCollection(url, id),
+    makeSelectUrlsForCollectionId(id),
+    (shuffleState, loopState, index, urls) => {
+      const loopList = loopState && loopState.collectionId === id && loopState.loop;
+      const shuffleUrls = shuffleState && shuffleState.collectionId === id && shuffleState.newUrls;
+
+      if (index > -1) {
+        const listUrls = shuffleUrls || urls;
+        let nextUrl;
+        if (index === 0 && loopList) {
+          nextUrl = listUrls[listUrls.length - 1];
+        } else {
+          nextUrl = listUrls[index - 1];
+        }
+        return nextUrl || null;
+      } else {
+        return null;
+      }
+    }
+  );
+
+export const makeSelectNextUrlForCollectionAndUrl = (id: string, url: string) =>
+  createSelector(
+    state => state.content.shuffleList,
+    state => state.content.loopList,
+    makeSelectIndexForUrlInCollection(url, id),
+    makeSelectUrlsForCollectionId(id),
+    (shuffleState, loopState, index, urls) => {
+      const loopList = loopState && loopState.collectionId === id && loopState.loop;
+      const shuffleUrls = shuffleState && shuffleState.collectionId === id && shuffleState.newUrls;
+
+      if (index > -1) {
+        const listUrls = shuffleUrls || urls;
+        // We'll get the next playble url
+        let remainingUrls = listUrls.slice(index + 1);
+        if (!remainingUrls.length && loopList) {
+          remainingUrls = listUrls.slice(0);
+        }
+        const nextUrl = remainingUrls && remainingUrls[0];
+        return nextUrl || null;
+      } else {
+        return null;
+      }
+    }
+  );
+
+export const makeSelectNameForCollectionId = (id: string) =>
+  createSelector(
+    makeSelectCollectionForId(id),
+    collection => {
+      return (collection && collection.name) || '';
+    }
+  );
+
+export const makeSelectCountForCollectionId = (id: string) =>
+  createSelector(
+    makeSelectCollectionForId(id),
+    collection => {
+      if (collection) {
+        if (collection.itemCount !== undefined) {
+          return collection.itemCount;
+        }
+        let itemCount = 0;
+        collection.items.map(item => {
+          if (item) {
+            itemCount += 1;
+          }
+        });
+        return itemCount;
+      }
+      return null;
+    }
+  );
--- a/src/redux/selectors/publish.js
+++ b/src/redux/selectors/publish.js
@ -43,7 +43,8 @@ export const selectPublishFormValues = createSelector(
  state => state.settings,
  selectIsStillEditing,
  (publishState, settingsState, isStillEditing) => {
-    const { pendingPublish, language, ...formValues } = publishState;
+    const { languages, ...formValues } = publishState;
+    const language = languages && languages.length && languages[0];
    const { clientSettings } = settingsState;
    const { language: languageSet } = clientSettings;

--- a/src/redux/selectors/wallet.js
+++ b/src/redux/selectors/wallet.js
@ -2,6 +2,7 @@ import { createSelector } from 'reselect';
 import * as TRANSACTIONS from 'constants/transaction_types';
 import { PAGE_SIZE, LATEST_PAGE_SIZE } from 'constants/transaction_list';
 import { selectClaimIdsByUri } from 'redux/selectors/claims';
+import parseData from 'util/parse-data';
 export const selectState = state => state.wallet || {};

 export const selectWalletState = selectState;
@ -267,6 +268,27 @@ export const selectIsFetchingTransactions = createSelector(
  state => state.fetchingTransactions
 );

+/**
+ * CSV of 'selectTransactionItems'.
+ */
+export const selectTransactionsFile = createSelector(
+  selectTransactionItems,
+  transactions => {
+    if (!transactions || transactions.length === 0) {
+      // No data.
+      return undefined;
+    }
+
+    const parsed = parseData(transactions, 'csv');
+    if (!parsed) {
+      // Invalid data, or failed to parse.
+      return null;
+    }
+
+    return parsed;
+  }
+);
+
 export const selectIsSendingSupport = createSelector(
  selectState,
  state => state.sendingSupport
--- a/src/util/parse-data.js
+++ b/src/util/parse-data.js
@ -0,0 +1,61 @@
+// JSON parser
+const parseJson = (data, filters = []) => {
+  const list = data.map(item => {
+    const temp = {};
+    // Apply filters
+    Object.entries(item).forEach(([key, value]) => {
+      if (!filters.includes(key)) temp[key] = value;
+    });
+    return temp;
+  });
+  // Beautify JSON
+  return JSON.stringify(list, null, '\t');
+};
+
+// CSV Parser
+// No need for an external module:
+// https://gist.github.com/btzr-io/55c3450ea3d709fc57540e762899fb85
+const parseCsv = (data, filters = []) => {
+  // Get items for header
+  const getHeaders = item => {
+    const list = [];
+    // Apply filters
+    Object.entries(item).forEach(([key]) => {
+      if (!filters.includes(key)) list.push(key);
+    });
+    // return headers
+    return list.join(',');
+  };
+
+  // Get rows content
+  const getData = list =>
+    list
+      .map(item => {
+        const row = [];
+        // Apply filters
+        Object.entries(item).forEach(([key, value]) => {
+          if (!filters.includes(key)) row.push(value);
+        });
+        // return rows
+        return row.join(',');
+      })
+      .join('\n');
+
+  // Return CSV string
+  return `${getHeaders(data[0])} \n ${getData(data)}`;
+};
+
+const parseData = (data, format, filters = []) => {
+  // Check for validation
+  const valid = data && data[0] && format;
+  // Pick a format
+  const formats = {
+    csv: list => parseCsv(list, filters),
+    json: list => parseJson(list, filters),
+  };
+
+  // Return parsed data: JSON || CSV
+  return valid && formats[format] ? formats[format](data) : undefined;
+};
+
+export default parseData;
--- a/yarn.lock
+++ b/yarn.lock
@ -1411,6 +1411,11 @@
  dependencies:
    "@types/yargs-parser" "*"

+"@ungap/from-entries@^0.2.1":
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/@ungap/from-entries/-/from-entries-0.2.1.tgz#7e86196b8b2e99d73106a8f25c2a068326346354"
+  integrity sha512-CAqefTFAfnUPwYqsWHXpOxHaq1Zo5UQ3m9Zm2p09LggGe57rqHoBn3c++xcoomzXKynAUuiBMDUCQvKMnXjUpA==
+
 abab@^1.0.4:
  version "1.0.4"
  resolved "https://registry.yarnpkg.com/abab/-/abab-1.0.4.tgz#5faad9c2c07f60dd76770f71cf025b62a63cfd4e"
Author	SHA1	Message	Date
zeppi	0f930c4a7b	sync-language	2021-10-08 16:12:32 -04:00
zeppi	32b5787071	pass channel_id on list update	2021-09-13 12:05:57 -04:00
Thomas Zarebczan	129b0ea3fa	Merge pull request #431 from saltrafael/list-thumb Changes for list thumbnail upload	2021-09-13 11:24:58 -04:00
saltrafael	e3bc848263	Add cb to thumbnail upload	2021-09-13 07:38:21 -03:00
zeppi	372e559cae	use replace for list updates	2021-09-11 13:18:41 -04:00
saltrafael	49b9db5aae	Fix autoplay not saving	2021-09-06 13:17:07 -04:00
Thomas Zarebczan	12a2ffc708	Merge pull request #426 from saltrafael/playback-controls Playback and List control changes	2021-09-01 14:08:36 -04:00
Thomas Zarebczan	95fa26f836	Merge pull request #428 from lbryio/ip/from.entries.poly Fix Object.fromEntries crash on some browsers	2021-09-01 12:04:46 -04:00
infiinte-persistence	dc264ec50c	Fix Object.fromEntries crash on some browsers ## Issue 6985 fromentries app crash - fix or add polyfill	2021-09-01 10:20:40 +08:00
saltrafael	aeb1f533b5	Playback and List control changes	2021-08-25 09:01:50 -03:00
zeppi	d016d8057b	cleanup	2021-08-23 10:20:22 -04:00
zeppi	0302a2f8d6	fix background collection update	2021-08-23 10:20:22 -04:00
zeppi	8fa92d872d	add isBackgroundUpdate to collection update	2021-08-23 10:20:22 -04:00
zeppi	e4d0662100	build	2021-08-06 12:33:10 -04:00
zeppi	036aa59086	fix collection edit	2021-08-06 12:33:10 -04:00
Thomas Zarebczan	c76dfbde27	Merge pull request #423 from lbryio/playlist-fetch-changes change collection fetch params	2021-08-03 14:18:20 -04:00
zeppi	7cc9923ed9	change collection fetch params	2021-08-03 14:05:03 -04:00
zeppi	60bd918d5e	U_S_P edited collection bugfix sync edited	2021-08-02 09:45:43 -04:00
saltrafael	9ebfc927d0	Change rLists selector	2021-07-30 11:01:18 -04:00
saltrafael	54ca8c4320	Filter rLists	2021-07-30 11:01:18 -04:00
saltrafael	bee9bf38dd	Add claim in collections selector	2021-07-30 11:01:18 -04:00
infiinte-persistence	aabae5ce59	Add custom comments-server settings ## Issue 5459: Add setting for changing your comment server. Visible on desktop (and possibly defaulting to Odysee URL), hidden on odysee.	2021-07-25 20:52:22 +08:00
zeppi	a327385cdf	clean	2021-07-15 17:14:28 -04:00
zeppi	64ce7aa99c	handle colons maybe	2021-07-15 17:14:28 -04:00
zeppi	34dfd384e4	logging	2021-07-15 17:14:28 -04:00
zeppi	707c60b813	parse either claimId separator	2021-07-15 17:14:28 -04:00
zeppi	8f66a2fe7c	fix pending ids selector	2021-07-05 15:57:47 -04:00
zeppi	729a4831ad	channel modlist on confirm	2021-07-05 09:42:33 -04:00
zeppi	88370997b4	cleanup	2021-07-05 09:42:33 -04:00
zeppi	b93598b0ff	fix bug canceling pending check early	2021-07-05 09:42:33 -04:00
zeppi	4cbb9a35c3	prefer pending and edited collections in selector	2021-07-05 09:42:33 -04:00
zeppi	04ce1df03d	collection check pending	2021-07-05 09:42:33 -04:00
zeppi	347fe25e85	cleanup	2021-07-05 09:42:33 -04:00
zeppi	e66698eadc	store pendingById	2021-07-05 09:42:33 -04:00
zeppi	0b505fb0f4	selectClaimIdIsPending	2021-06-23 10:47:24 -04:00
Thomas Zarebczan	508e8d36fd	Merge pull request #416 from saltrafael/master Fix breaking when no languages set	2021-06-14 11:13:06 -04:00
saltrafael	0758827e6d	fix breaking when no languages set	2021-06-13 08:51:49 -03:00
Thomas Zarebczan	166c3b2832	Merge pull request #414 from saltrafael/master Don't reset content language on edit	2021-06-11 11:45:35 -04:00
Thomas Zarebczan	d298c00f24	Merge pull request #415 from lbryio/fix-autoplay fix autoplay after playlist click and select next playable	2021-06-10 17:20:08 -04:00
zeppi	06b09f5a81	add list reducer key consts	2021-06-10 16:07:41 -04:00
zeppi	4dfc4689c6	fix autoplay after playlist click and select next playable	2021-06-10 14:03:11 -04:00
saltrafael	85ad697e0a	Don't reset content language on edit	2021-06-09 11:32:22 -03:00
zeppi	609f13991f	bugfix	2021-06-08 11:51:49 -04:00
zeppi	503e18be1b	refactor select collection index / next	2021-06-08 11:51:49 -04:00
zeppi	32a85a9ff3	cleanup	2021-06-08 11:51:49 -04:00
zeppi	40fc75320d	fix crash on abandoned collection claim	2021-06-08 11:51:49 -04:00
zeppi	e20baa0683	fix sync bringing back unpublished	2021-06-08 11:51:49 -04:00
zeppi	a1cb16400d	bugfix	2021-06-08 11:51:49 -04:00
zeppi	9461cf1bee	cleanup cleanup cleanup	2021-06-08 11:51:49 -04:00
zeppi	7e049487c3	fix sync	2021-06-08 11:51:49 -04:00
zeppi	f7775fd837	finalize collections sync keys	2021-06-08 11:51:49 -04:00
zeppi	06531c6b48	fix tags bug, flow	2021-06-08 11:51:49 -04:00
zeppi	b280d66f5d	return new collection on publish	2021-06-08 11:51:49 -04:00
zeppi	bfb50ebeb5	handle collection claim delete	2021-06-08 11:51:49 -04:00
zeppi	06ce8c623c	refactor fetch to fix pending	2021-06-08 11:51:49 -04:00
zeppi	f8ff4cfc8f	thumb param	2021-06-08 11:51:49 -04:00
zeppi	e34f451025	collections length	2021-06-08 11:51:49 -04:00
zeppi	d3c045b037	prefer title for collection name on resolve	2021-06-08 11:51:49 -04:00
zeppi	63946a0a6d	pending, edit fixes, support collectionCount	2021-06-08 11:51:49 -04:00
zeppi	dd697ed70e	make edits work	2021-06-08 11:51:49 -04:00
zeppi	fd2551e764	fix pending, support new collection add ui	2021-06-08 11:51:49 -04:00
zeppi	8d0f9c18fd	wip wip clean clean review wip wallet sync wip collection publishing build refactor, publishing, pending, editing wip wip fetch collections on resolve select collections or playlists build return edit success fix collection claimId selector small rename flow type fixes collection edit params type param and flowtypes	2021-06-08 11:51:49 -04:00
Thomas Zarebczan	757e8c24ec	Merge pull request #413 from lbryio/ip/thumbnail-error-part-2 Clear 'thumbnailError' when uploading new one	2021-05-17 15:46:25 -04:00
infiinte-persistence	ecfcc95beb	Clear 'thumbnailError' when uploading new one ## Issue "thumbnail is invalid" not reset with new thumbnail upload #6044 https://github.com/lbryio/lbry-desktop/issues/6044 ## Change The previous PR only covered the scenario of changing between NEW and EDIT. This one covers "uploading new".	2021-05-18 01:23:37 +08:00
Thomas Zarebczan	b2ad71fb74	Merge pull request #412 from lbryio/ip/release-time Change how release_time is edited.	2021-05-14 17:30:25 -04:00
infiinte-persistence	35dd7650fb	Change how release_time is edited. - `releaseTime` is now a number instead of a string, matching `release_time`. It was getting confusing what the variable units were. - `releaseTime` will always match `release_time` for an edit. It will be used in the GUI to reset just the date to the original, instead of having to reset the entire form. - `releaseTimeEdited` will be used by `updatePublishForm` in the GUI to represent the desired new release time. Set to `undefined` if we don't want to change the date.	2021-05-13 07:57:01 +08:00
infiinte-persistence	babfec7d43	Complete rename of 'release_time' I believe this was missed out in `c31161c4`	2021-05-13 07:57:00 +08:00
Thomas Zarebczan	6fc11454eb	Merge pull request #411 from lbryio/ip/thumbnail-error Define default value for 'thumbnailError'	2021-05-12 10:20:33 -04:00
infiinte-persistence	3b853b6ddd	Define default value for 'thumbnailError' ## Issue "thumbnail is invalid" not reset with new thumbnail upload #6044 https://github.com/lbryio/lbry-desktop/issues/6044 ## Change Defining a default value will cover both CLEAR_PUBLISH and DO_PREPARE_EDIT	2021-05-11 11:02:48 +08:00
Thomas Zarebczan	41ef1117e5	Merge pull request #408 from lbryio/ip/bump-transaction-page-size doFetchTransactions: bump pageSize to 999999; remove doFetchSupport	2021-04-26 15:11:24 -04:00
zeppi	66c77fc39b	delay preference set two seconds	2021-04-26 15:06:00 -04:00
infiinte-persistence	e5c0b5f0a6	doFetchTransactions: bump pageSize to 999999; remove doFetchSupport ## Issue 5899 Re-add ability to export transactions	2021-04-26 12:26:36 +08:00
Sean Yesmunt	7e17344683	remove unused comment types	2021-04-23 14:52:16 -04:00
Sean Yesmunt	b511282c35	superchat support	2021-04-23 14:52:16 -04:00
Thomas Zarebczan	eb37009a98	Merge pull request #405 from lbryio/feat-supportAsyncForDesktop support claim search async dispatch	2021-04-23 11:12:44 -04:00
zeppi	c2e03fa71d	support claim search async dispatch	2021-04-22 22:31:08 -04:00
Thomas Zarebczan	4e37ab6580	Merge pull request #404 from lbryio/ip/export-transactions Transaction export: move file-creation to background.	2021-04-19 16:44:04 -04:00
infiinte-persistence	a0bfbee958	Transaction export: move file-creation to background.	2021-04-17 22:09:02 +08:00