2225885137

Committed 26 Apr 2022 09:57AM UTC coverage: 35.394% (-0.3%) from 35.726%

Build Type

github

Committed by GitHub

Commit Message

Merge 450a4715b into f05d56b96

Pull Request Pull Request #3818: Release 3.25.0

Run Details

1270 of 4533 branches covered (28.02%)

Branch coverage included in aggregate %.

93 of 356 new or added lines in 58 files covered. (26.12%)

92 existing lines in 21 files now uncovered.

3591 of 9201 relevant lines covered (39.03%)

35.53 hits per line

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

7.69

/src/logic/collectibles/sources/Gnosis.ts

import { SafeCollectibleResponse, TokenType } from '@gnosis.pm/safe-react-gateway-sdk'

import { Collectibles, NFTAsset, NFTAssets, NFTTokens } from 'src/logic/collectibles/sources/collectibles.d'
import { sameAddress } from 'src/logic/wallets/ethAddresses'
import NFTIcon from 'src/routes/safe/components/Balances/assets/nft_icon.png'
import { fetchSafeCollectibles } from 'src/logic/tokens/api/fetchSafeCollectibles'
import { Errors, logError } from 'src/logic/exceptions/CodedException'

type TokenResult = {
  address: string
  decimals?: number
  logoUri: string
  name: string
  symbol: string
  type: TokenType
}

type FetchResult = {
  erc721Assets: TokenResult[]
  erc721Tokens: SafeCollectibleResponse[]
}
class Gnosis {
  _getAssetsFromTokens = (tokens: SafeCollectibleResponse[]): TokenResult[] => {
    const assets: TokenResult[] = tokens.map(({ address, logoUri, tokenName, tokenSymbol }) => ({
      address,
      decimals: undefined,
      logoUri,
      name: tokenName,
      symbol: tokenSymbol,
      type: TokenType.ERC721,
    }))

    return assets
  }

  _fetch = async (safeAddress: string): Promise<FetchResult> => {
    const collectibles: FetchResult = {
      erc721Assets: [],
      erc721Tokens: [],
    }

    try {
      const tokens = await fetchSafeCollectibles(safeAddress)
      collectibles.erc721Assets = this._getAssetsFromTokens(tokens)
      collectibles.erc721Tokens = tokens || []
    } catch (error) {
      logError(Errors._604, error.message)
    }

    return collectibles
  }

  static extractNFTAsset = (asset: TokenResult, nftTokens: NFTTokens): NFTAsset => {
    const mainAssetAddress = asset.address
    const numberOfTokens = nftTokens.filter(({ assetAddress }) => sameAddress(assetAddress, mainAssetAddress)).length

    return {
      address: mainAssetAddress,
      description: asset.name,
      image: asset.logoUri || NFTIcon,
      name: asset.name,
      numberOfTokens,
      slug: `${mainAssetAddress}_${asset.name}`,
      symbol: asset.symbol,
    }
  }

  static extractAssets(assets: TokenResult[], nftTokens: NFTTokens): NFTAssets {
    const extractedAssets = {}

    assets.forEach((asset) => {
      const address = asset.address

      if (extractedAssets[address] === undefined) {
        extractedAssets[address] = Gnosis.extractNFTAsset(asset, nftTokens)
      }
    })

    return extractedAssets
  }

  static extractTokens(tokens: SafeCollectibleResponse[]): NFTTokens {
    const items = tokens.map((token) => ({
      assetAddress: token.address,
      color: 'red',
      description: token.description || '',
      image: token.imageUri || NFTIcon,
      name: token.name || '',
      tokenId: token.id,
    }))
    return items
  }

  /**
   * Fetches from OpenSea the list of collectibles, grouped by category,
   * for the provided Safe Address in the specified Network
   * @param {string} safeAddress
   * @returns {Promise<Collectibles>}
   */
  async fetchCollectibles(safeAddress: string): Promise<Collectibles> {
    const { erc721Assets, erc721Tokens } = await this._fetch(safeAddress)

    const nftTokens = Gnosis.extractTokens(erc721Tokens)
    const nftAssets = Gnosis.extractAssets(erc721Assets, nftTokens)

    return { nftTokens, nftAssets }
  }
}

export default Gnosis

1	import { SafeCollectibleResponse, TokenType } from '@gnosis.pm/safe-react-gateway-sdk'
2
3	import { Collectibles, NFTAsset, NFTAssets, NFTTokens } from 'src/logic/collectibles/sources/collectibles.d'
4	import { sameAddress } from 'src/logic/wallets/ethAddresses'
5	import NFTIcon from 'src/routes/safe/components/Balances/assets/nft_icon.png'
6	import { fetchSafeCollectibles } from 'src/logic/tokens/api/fetchSafeCollectibles'
7	import { Errors, logError } from 'src/logic/exceptions/CodedException'
8
9	type TokenResult = {
10	address: string
11	decimals?: number
12	logoUri: string
13	name: string
14	symbol: string
15	type: TokenType
16	}
17
18	type FetchResult = {
19	erc721Assets: TokenResult[]
20	erc721Tokens: SafeCollectibleResponse[]
21	}
22	class Gnosis {
23	_getAssetsFromTokens = (tokens: SafeCollectibleResponse[]): TokenResult[] => {	4✔
24	const assets: TokenResult[] = tokens.map(({ address, logoUri, tokenName, tokenSymbol }) => ({	×
25	address,
26	decimals: undefined,
27	logoUri,
28	name: tokenName,
29	symbol: tokenSymbol,
30	type: TokenType.ERC721,
31	}))
32
33	return assets	×
34	}
35
36	_fetch = async (safeAddress: string): Promise<FetchResult> => {	4✔
37	const collectibles: FetchResult = {	×
38	erc721Assets: [],
39	erc721Tokens: [],
40	}
41
42	try {	×
43	const tokens = await fetchSafeCollectibles(safeAddress)	×
44	collectibles.erc721Assets = this._getAssetsFromTokens(tokens)	×
45	collectibles.erc721Tokens = tokens \|\| []	×
46	} catch (error) {
47	logError(Errors._604, error.message)	×
48	}
49
50	return collectibles	×
51	}
52
53	static extractNFTAsset = (asset: TokenResult, nftTokens: NFTTokens): NFTAsset => {	4✔
54	const mainAssetAddress = asset.address	×
NEW 55	const numberOfTokens = nftTokens.filter(({ assetAddress }) => sameAddress(assetAddress, mainAssetAddress)).length	×
56
57	return {	×
58	address: mainAssetAddress,
59	description: asset.name,
60	image: asset.logoUri \|\| NFTIcon,	×
61	name: asset.name,
62	numberOfTokens,
63	slug: `${mainAssetAddress}_${asset.name}`,
64	symbol: asset.symbol,
65	}
66	}
67
68	static extractAssets(assets: TokenResult[], nftTokens: NFTTokens): NFTAssets {
69	const extractedAssets = {}	×
70
71	assets.forEach((asset) => {	×
72	const address = asset.address	×
73
74	if (extractedAssets[address] === undefined) {	×
75	extractedAssets[address] = Gnosis.extractNFTAsset(asset, nftTokens)	×
76	}
77	})
78
79	return extractedAssets	×
80	}
81
82	static extractTokens(tokens: SafeCollectibleResponse[]): NFTTokens {
83	const items = tokens.map((token) => ({	×
84	assetAddress: token.address,
85	color: 'red',
86	description: token.description \|\| '',	×
87	image: token.imageUri \|\| NFTIcon,	×
88	name: token.name \|\| '',	×
89	tokenId: token.id,
90	}))
NEW 91	return items	×
92	}
93
94	/**
95	* Fetches from OpenSea the list of collectibles, grouped by category,
96	* for the provided Safe Address in the specified Network
97	* @param {string} safeAddress
98	* @returns {Promise<Collectibles>}
99	*/
100	async fetchCollectibles(safeAddress: string): Promise<Collectibles> {
101	const { erc721Assets, erc721Tokens } = await this._fetch(safeAddress)	×
102
103	const nftTokens = Gnosis.extractTokens(erc721Tokens)	×
104	const nftAssets = Gnosis.extractAssets(erc721Assets, nftTokens)	×
105
106	return { nftTokens, nftAssets }	×
107	}
108	}
109
110	export default Gnosis

safe-global / safe-react / 2225885137

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