18878690898

Committed 28 Oct 2025 02:46PM UTC coverage: 49.137% (-0.4%) from 49.515%

Build # 18878690898

Build Type

push

github

Committed by

gooddollar-techadmin

Commit Message

chore: release qa version 1.63.1-0 [skip build]

Run Details

616 of 1530 branches covered (40.26%)

Branch coverage included in aggregate %.

1888 of 3566 relevant lines covered (52.94%)

7.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

20.0

/src/server/blockchain/MultiWallet.js

// @flow
import { assign, every, forOwn, isEmpty, isError, map, some } from 'lodash'
import AdminWallet from './AdminWallet'
import { CeloAdminWallet } from './CeloAdminWallet'
import { BaseAdminWallet } from './BaseAdminWallet'
import { XdcAdminWallet } from './XdcAdminWallet'

import conf from '../server.config'
import logger from '../../imports/logger'
import { DefenderRelayer } from './DefenderRelayer'
const multiLogger = logger.child({ from: 'MultiWallet' })

class MultiWallet {
  mainWallet = null
  otherWallets = []
  wallets = []
  walletsMap = {}
  defaultChainId = null
  signer: DefenderRelayer = null

  get ready() {
    return Promise.all(map(this.wallets, 'ready')).then(() => this.mainWallet.addresses)
  }

  constructor(walletsMap) {
    let mainWallet
    let defaultChainId
    this.signer = DefenderRelayer.getInstance()

    forOwn(walletsMap, (wallet, chainId) => {
      this.wallets.push(wallet)

      if (mainWallet) {
        this.otherWallets.push(wallet)
      } else {
        mainWallet = wallet
        defaultChainId = chainId
      }
    })

    multiLogger.debug('MultiWallet constructor:', {
      wallets: Object.keys(walletsMap),
      mainWallet: mainWallet.networkId,
      otherWallets: this.otherWallets.map(_ => _.networkId)
    })

    assign(this, { walletsMap, mainWallet, defaultChainId })
  }

  signMessage(message: string) {
    return this.signer.signMessage(message)
  }

  async banInFaucet(account, chainId = 'all', log = multiLogger) {
    const runTx = wallet => wallet.banInFaucet(account, log)

    log.debug('MultiWallet: banInFaucet request:', { account, chainId })
    if (chainId === 'all') {
      // ban on chains that have ubi
      const results = await Promise.all(
        this.wallets.filter(_ => Number(_.UBIContract?._address) > 0).map(wallet => runTx(wallet).catch(e => e))
      )
      const error = results.find(isError)

      if (error) {
        throw error
      }

      return results
    }

    const { walletsMap } = this

    if (chainId in walletsMap) return runTx(walletsMap[chainId])

    throw new Error(`unsupported chain ${chainId}`)
  }

  async topWallet(account, chainId = null, log = multiLogger) {
    const runTx = wallet => wallet.topWallet(account, log)

    log.debug('MultiWallet: topWallet request:', { account, chainId })
    if (chainId === 'all') {
      // topwallet on chains that have ubi
      const results = await Promise.all(
        this.wallets.filter(_ => Number(_.UBIContract?._address) > 0).map(wallet => runTx(wallet).catch(e => e))
      )
      const error = results.find(isError)

      if (error) {
        throw error
      }

      return results
    }

    const { walletsMap } = this

    if (chainId in walletsMap) return runTx(walletsMap[chainId])

    throw new Error(`unsupported chain ${chainId}`)
  }

  async whitelistUser(account, did, chainId = null, log = multiLogger) {
    return Promise.all(this.wallets.map(wallet => wallet.whitelistUser(account, did, chainId, 0, log)))
  }

  async removeWhitelisted(account) {
    return Promise.all(this.wallets.map(wallet => wallet.removeWhitelisted(account)))
  }

  async verifiedStatus(account) {
    return Promise.all(
      this.wallets.map(wallet => wallet.isVerified(account).then(status => ({ chainId: wallet.networkId, status })))
    )
  }

  async isVerified(account) {
    return this.mainWallet.isVerified(account)
  }

  async lastAuthenticated(account) {
    return this.mainWallet.getLastAuthenticated(account)
  }

  async syncWhitelist(account, log = multiLogger) {
    try {
      const isVerified = await Promise.all(this.wallets.map(wallet => wallet.isVerified(account)))

      log.debug('syncwhitelist isVerified:', { account, isVerified })

      if (isEmpty(isVerified) || every(isVerified) || !some(isVerified)) {
        return false
      }

      const mainWallet = this.wallets[isVerified.findIndex(_ => _)]

      const [did, lastAuthenticated] = await Promise.all([
        mainWallet.getDID(account).catch(() => account),
        mainWallet.getLastAuthenticated(account).catch(() => 0)
      ])
      const chainId = mainWallet.networkId

      log.debug('syncwhitelist did:', { account, did, lastAuthenticated, chainId })

      await Promise.all(
        isVerified.map(async (status, index) => {
          log.debug('syncwhitelist whitelisting on wallet:', { status, index, account })
          if (status) {
            return
          }

          await this.wallets[index].whitelistUser(account, did, chainId, lastAuthenticated, log)
        })
      )

      return true
    } catch (e) {
      log.error('syncwhitelist failed:', e.message, e, { account })
      throw e
    }
  }

  async getAuthenticationPeriod() {
    return this.mainWallet.getAuthenticationPeriod()
  }

  async registerRedtent(account: string, countryCode: string, log = multiLogger) {
    return Promise.all(this.wallets.map(wallet => wallet.registerRedtent(account, countryCode, log)))
  }
}

let otherWallets = {}
if (conf.env !== 'test') {
  const celoWallet = new CeloAdminWallet()
  otherWallets = {
    42220: celoWallet,
    8453: new BaseAdminWallet({}, celoWallet),
    50: new XdcAdminWallet({})
  }
}

export default new MultiWallet({
  122: AdminWallet, // "main" wallet goes first
  ...otherWallets
})

1	// @flow
2	import { assign, every, forOwn, isEmpty, isError, map, some } from 'lodash'
3	import AdminWallet from './AdminWallet'
4	import { CeloAdminWallet } from './CeloAdminWallet'
5	import { BaseAdminWallet } from './BaseAdminWallet'
6	import { XdcAdminWallet } from './XdcAdminWallet'
7
8	import conf from '../server.config'
9	import logger from '../../imports/logger'
10	import { DefenderRelayer } from './DefenderRelayer'
11	const multiLogger = logger.child({ from: 'MultiWallet' })	5✔
12
13	class MultiWallet {
14	mainWallet = null	5✔
15	otherWallets = []	5✔
16	wallets = []	5✔
17	walletsMap = {}	5✔
18	defaultChainId = null	5✔
19	signer: DefenderRelayer = null	5✔
20
21	get ready() {
22	return Promise.all(map(this.wallets, 'ready')).then(() => this.mainWallet.addresses)	3✔
23	}
24
25	constructor(walletsMap) {
26	let mainWallet
27	let defaultChainId
28	this.signer = DefenderRelayer.getInstance()	5✔
29
30	forOwn(walletsMap, (wallet, chainId) => {	5✔
31	this.wallets.push(wallet)	5✔
32
33	if (mainWallet) {	5!
34	this.otherWallets.push(wallet)	×
35	} else {
36	mainWallet = wallet	5✔
37	defaultChainId = chainId	5✔
38	}
39	})
40
41	multiLogger.debug('MultiWallet constructor:', {	5✔
42	wallets: Object.keys(walletsMap),
43	mainWallet: mainWallet.networkId,
44	otherWallets: this.otherWallets.map(_ => _.networkId)	×
45	})
46
47	assign(this, { walletsMap, mainWallet, defaultChainId })	5✔
48	}
49
50	signMessage(message: string) {
51	return this.signer.signMessage(message)	×
52	}
53
54	async banInFaucet(account, chainId = 'all', log = multiLogger) {	×
55	const runTx = wallet => wallet.banInFaucet(account, log)	×
56
57	log.debug('MultiWallet: banInFaucet request:', { account, chainId })	×
58	if (chainId === 'all') {	×
59	// ban on chains that have ubi
60	const results = await Promise.all(	×
61	this.wallets.filter(_ => Number(_.UBIContract?._address) > 0).map(wallet => runTx(wallet).catch(e => e))	×
62	)
63	const error = results.find(isError)	×
64
65	if (error) {	×
66	throw error	×
67	}
68
69	return results	×
70	}
71
72	const { walletsMap } = this	×
73
74	if (chainId in walletsMap) return runTx(walletsMap[chainId])	×
75
76	throw new Error(`unsupported chain ${chainId}`)	×
77	}
78
79	async topWallet(account, chainId = null, log = multiLogger) {	×
80	const runTx = wallet => wallet.topWallet(account, log)	×
81
82	log.debug('MultiWallet: topWallet request:', { account, chainId })	×
83	if (chainId === 'all') {	×
84	// topwallet on chains that have ubi
85	const results = await Promise.all(	×
86	this.wallets.filter(_ => Number(_.UBIContract?._address) > 0).map(wallet => runTx(wallet).catch(e => e))	×
87	)
88	const error = results.find(isError)	×
89
90	if (error) {	×
91	throw error	×
92	}
93
94	return results	×
95	}
96
97	const { walletsMap } = this	×
98
99	if (chainId in walletsMap) return runTx(walletsMap[chainId])	×
100
101	throw new Error(`unsupported chain ${chainId}`)	×
102	}
103
104	async whitelistUser(account, did, chainId = null, log = multiLogger) {	×
105	return Promise.all(this.wallets.map(wallet => wallet.whitelistUser(account, did, chainId, 0, log)))	×
106	}
107
108	async removeWhitelisted(account) {
109	return Promise.all(this.wallets.map(wallet => wallet.removeWhitelisted(account)))	×
110	}
111
112	async verifiedStatus(account) {
113	return Promise.all(	×
114	this.wallets.map(wallet => wallet.isVerified(account).then(status => ({ chainId: wallet.networkId, status })))	×
115	)
116	}
117
118	async isVerified(account) {
119	return this.mainWallet.isVerified(account)	×
120	}
121
122	async lastAuthenticated(account) {
123	return this.mainWallet.getLastAuthenticated(account)	×
124	}
125
126	async syncWhitelist(account, log = multiLogger) {	×
127	try {	×
128	const isVerified = await Promise.all(this.wallets.map(wallet => wallet.isVerified(account)))	×
129
130	log.debug('syncwhitelist isVerified:', { account, isVerified })	×
131
132	if (isEmpty(isVerified) \|\| every(isVerified) \|\| !some(isVerified)) {	×
133	return false	×
134	}
135
136	const mainWallet = this.wallets[isVerified.findIndex(_ => _)]	×
137
138	const [did, lastAuthenticated] = await Promise.all([	×
139	mainWallet.getDID(account).catch(() => account),	×
140	mainWallet.getLastAuthenticated(account).catch(() => 0)	×
141	])
142	const chainId = mainWallet.networkId	×
143
144	log.debug('syncwhitelist did:', { account, did, lastAuthenticated, chainId })	×
145
146	await Promise.all(	×
147	isVerified.map(async (status, index) => {
148	log.debug('syncwhitelist whitelisting on wallet:', { status, index, account })	×
149	if (status) {	×
150	return	×
151	}
152
153	await this.wallets[index].whitelistUser(account, did, chainId, lastAuthenticated, log)	×
154	})
155	)
156
157	return true	×
158	} catch (e) {
159	log.error('syncwhitelist failed:', e.message, e, { account })	×
160	throw e	×
161	}
162	}
163
164	async getAuthenticationPeriod() {
165	return this.mainWallet.getAuthenticationPeriod()	×
166	}
167
168	async registerRedtent(account: string, countryCode: string, log = multiLogger) {	×
169	return Promise.all(this.wallets.map(wallet => wallet.registerRedtent(account, countryCode, log)))	1✔
170	}
171	}
172
173	let otherWallets = {}	5✔
174	if (conf.env !== 'test') {	5!
175	const celoWallet = new CeloAdminWallet()	×
176	otherWallets = {	×
177	42220: celoWallet,
178	8453: new BaseAdminWallet({}, celoWallet),
179	50: new XdcAdminWallet({})
180	}
181	}
182
183	export default new MultiWallet({
184	122: AdminWallet, // "main" wallet goes first
185	...otherWallets
186	})

GoodDollar / GoodServer / 18878690898

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous