frame/main/externalData/observers/index.ts at 249203bab00645083d15827312bbfedc7ad60939 · floating/frame · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
import deepEqual from 'deep-equal'

import { arraysEqual } from '../../../resources/utils'
import { storeApi } from '../storeApi'

import type { Token } from '../../store/state/types'

interface ActiveAddressChangedHandler {
  addressChanged: (address: Address) => void
}

interface AccountsChangedHandler {
  accountsChanged: (addresses: Address[]) => void
}

interface TokensChangedHandler {
  customTokensChanged: (address: Address, tokens: Token[]) => void
  knownTokensChanged: (address: Address, tokens: Token[]) => void
}

interface TrayChangedHandler {
  trayToggled: (open: boolean) => void
}

interface ChainIdsChangedHandler {
  chainsChanged: (chains: number[]) => void
}

function createChainsObserver(handler: ChainIdsChangedHandler) {
  let availableChains = storeApi.getConnectedNetworkIds()

  return function () {
    const currentChains = storeApi.getConnectedNetworkIds()

    if (!arraysEqual(currentChains, availableChains)) {
      const toAdd = currentChains.filter((c) => !availableChains.includes(c))
      const toRemove = availableChains.filter((c) => !currentChains.includes(c))
      availableChains = currentChains

      if (toAdd.length || toRemove.length) {
        setTimeout(() => {
          handler.chainsChanged(currentChains)
        }, 0)
      }
    }
  }
}

function createActiveAccountObserver(handler: ActiveAddressChangedHandler) {
  let activeAccount = storeApi.getActiveAddress()

  return function () {
    const currentActiveAccount = storeApi.getActiveAddress()

    if (currentActiveAccount !== activeAccount) {
      activeAccount = currentActiveAccount
      setTimeout(() => {
        handler.addressChanged(activeAccount)
      }, 0)
    }
  }
}

//TODO: do we need to sort the arrays?
function createTokensObserver(handler: TokensChangedHandler) {
  let customTokens = storeApi.getCustomTokens()
  let knownTokens = storeApi.getKnownTokens()

  return function () {
    const currentAccount = storeApi.getActiveAddress()
    const currentCustomTokens = storeApi.getCustomTokens()
    const currentKnownTokens = storeApi.getKnownTokens(currentAccount)

    if (!deepEqual(currentCustomTokens, customTokens)) {
      customTokens = currentCustomTokens

      setTimeout(() => {
        handler.customTokensChanged(currentAccount, customTokens)
      }, 0)
    }

    if (!deepEqual(currentKnownTokens, knownTokens)) {
      knownTokens = currentKnownTokens

      setTimeout(() => {
        handler.knownTokensChanged(currentAccount, knownTokens)
      }, 0)
    }
  }
}

function createTrayObserver(handler: TrayChangedHandler) {
  let trayOpen = storeApi.getTrayOpened()

  return function () {
    const currentTrayOpen = storeApi.getTrayOpened()

    if (currentTrayOpen !== trayOpen) {
      trayOpen = currentTrayOpen
      setTimeout(() => {
        handler.trayToggled(trayOpen)
      }, 0)
    }
  }
}

function createAccountsObserver(handler: AccountsChangedHandler) {
  let accounts = storeApi.getAccounts()

  return function () {
    const currentAccounts = storeApi.getAccounts()

    if (!arraysEqual(currentAccounts, accounts)) {
      accounts = currentAccounts
      setTimeout(() => {
        handler.accountsChanged(accounts)
      }, 0)
    }
  }
}

export {
  createAccountsObserver,
  createActiveAccountObserver,
  createChainsObserver,
  createTokensObserver,
  createTrayObserver
}