6081449930

Committed 05 Sep 2023 07:21AM UTC coverage: 92.137% (-0.4%) from 92.5%

Build Type

github

Committed by Usame Algan

Commit Message

fix: Simplify type, adjust builder

Pull Request Pull Request #671: feat: Human readable v2

Run Details

1165 of 1388 branches covered (0.0%)

Branch coverage included in aggregate %.

43 of 52 new or added lines in 10 files covered. (82.69%)

2 existing lines in 2 files now uncovered.

4530 of 4793 relevant lines covered (94.51%)

160.07 hits per line

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

79.78

/src/routes/transactions/mappers/common/human-description.mapper.ts

import { Hex } from 'viem/src/types/misc';
import { Inject, Injectable } from '@nestjs/common';
import { formatUnits, isHex } from 'viem';
import { ITokenRepository } from '@/domain/tokens/token.repository.interface';
import { TokenRepository } from '@/domain/tokens/token.repository';
import { MAX_UINT256 } from '../../constants';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { IHumanDescriptionRepository } from '@/domain/human-description/human-description.repository.interface';
import { HumanDescriptionRepository } from '@/domain/human-description/human-description.repository';
import {
  HumanDescriptionFragment,
  TokenValueFragment,
  ValueType,
} from '@/domain/human-description/entities/human-description.entity';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
import { isMultisigTransaction } from '@/domain/safe/entities/transaction.entity';
import { SafeAppInfoMapper } from './safe-app-info.mapper';
import {
  RichInfo,
  RichTokenValueFragment,
  RichTextFragment,
  RichInfoFragment,
} from '@/routes/transactions/entities/human-description.entity';

@Injectable()
export class HumanDescriptionMapper {
  private static SIG_HASH_INDEX = 10;

  constructor(
    @Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IHumanDescriptionRepository)
    private readonly humanDescriptionRepository: HumanDescriptionRepository,
    private readonly safeAppInfoMapper: SafeAppInfoMapper,
  ) {}

  async mapRichInfo(
    transaction: MultisigTransaction | ModuleTransaction,
    chainId: string,
  ): Promise<RichInfo | null> {
    if (!transaction.data || !isHex(transaction.data) || !transaction.to) {
      return null;
    }

    const sigHash = this.getSigHash(transaction.data);

    if (!sigHash) return null;

    try {
      const humanDescriptionFragments =
        this.humanDescriptionRepository.getHumanDescription({
          functionSignatureHash: sigHash,
          to: transaction.to,
          data: transaction.data,
        });

      const richInfoFragments = await this.enrichFragments(
        humanDescriptionFragments,
        transaction,
        chainId,
      );

      const richInfo = await this.enrichSafeAppInfo(
        richInfoFragments,
        transaction,
        chainId,
      );

      return {
        fragments: richInfo,
      };
    } catch (error) {
      this.loggingService.debug(
        `Error trying to decode the input data: ${error.message}`,
      );
      return null;
    }
  }

  mapHumanDescription(richInfo: RichInfo | null): string | null {
    if (!richInfo?.fragments) return null;

    return richInfo.fragments
      .map((fragment) => {
        if (fragment.type === ValueType.TokenValue) {
          return `${fragment.value} ${fragment.richData?.symbol}`;
        }

        return fragment.value;
      })
      .join(' ');
  }

  async enrichFragments(
    fragments: HumanDescriptionFragment[],
    transaction: MultisigTransaction | ModuleTransaction,
    chainId: string,
  ): Promise<RichInfoFragment[]> {
    return Promise.all(
      fragments.map(async (fragment) => {
        switch (fragment.type) {
          case ValueType.TokenValue:
            return this.enrichTokenValue(fragment, transaction, chainId);
          case ValueType.Address:
          default:
            return { ...fragment, richData: null };
        }
      }),
    );
  }

  async enrichTokenValue(
    fragment: TokenValueFragment,
    transaction: MultisigTransaction | ModuleTransaction,
    chainId: string,
  ): Promise<RichTokenValueFragment> {
    try {
      const token = await this.tokenRepository.getToken({
        chainId,
        address: transaction.to,
      });

      let amount: string;
      if (fragment.value.amount === MAX_UINT256) {
        amount = 'unlimited';
      } else if (token && token.decimals) {
        amount = formatUnits(fragment.value.amount, token.decimals);
      } else {
        amount = fragment.value.amount.toString();
      }

      return <RichTokenValueFragment>{
        type: ValueType.TokenValue,
        value: amount,
        richData: {
          symbol: token.symbol,
          logoUri: token.logoUri,
        },
      };
    } catch (error) {
      return {
        type: ValueType.TokenValue,
        value: fragment.value.amount.toString(),
        richData: {
          symbol: null,
          logoUri: null,
        },
      };
    }
  }

  async enrichSafeAppInfo(
    fragments: RichInfoFragment[],
    transaction: MultisigTransaction | ModuleTransaction,
    chainId: string,
  ): Promise<RichInfoFragment[]> {
    const safeAppInfo = isMultisigTransaction(transaction)
      ? await this.safeAppInfoMapper.mapSafeAppInfo(chainId, transaction)
      : null;

    if (safeAppInfo) {
      fragments.push(<RichTextFragment>{
        type: ValueType.Text,
        value: `via ${safeAppInfo.name}`,
        richData: null,
      });
    }

    return fragments;
  }

  private getSigHash(data: Hex): Hex | null {
    const dataStart = data.slice(0, HumanDescriptionMapper.SIG_HASH_INDEX);

    return isHex(dataStart) ? dataStart : null;
  }
}

1	import { Hex } from 'viem/src/types/misc';
2	import { Inject, Injectable } from '@nestjs/common';	66✔
3	import { formatUnits, isHex } from 'viem';	66✔
4	import { ITokenRepository } from '@/domain/tokens/token.repository.interface';	66✔
5	import { TokenRepository } from '@/domain/tokens/token.repository';	66✔
6	import { MAX_UINT256 } from '../../constants';	66✔
7	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	66✔
8	import { IHumanDescriptionRepository } from '@/domain/human-description/human-description.repository.interface';	66✔
9	import { HumanDescriptionRepository } from '@/domain/human-description/human-description.repository';	66✔
10	import {	66✔
11	HumanDescriptionFragment,
12	TokenValueFragment,
13	ValueType,
14	} from '@/domain/human-description/entities/human-description.entity';
15	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
16	import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
17	import { isMultisigTransaction } from '@/domain/safe/entities/transaction.entity';	66✔
18	import { SafeAppInfoMapper } from './safe-app-info.mapper';	66✔
19	import {
20	RichInfo,
21	RichTokenValueFragment,
22	RichTextFragment,
23	RichInfoFragment,
24	} from '@/routes/transactions/entities/human-description.entity';
25
26	@Injectable()
27	export class HumanDescriptionMapper {	66✔
28	private static SIG_HASH_INDEX = 10;	66✔
29
30	constructor(
31	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	442✔
32	@Inject(LoggingService) private readonly loggingService: ILoggingService,	442✔
33	@Inject(IHumanDescriptionRepository)
34	private readonly humanDescriptionRepository: HumanDescriptionRepository,	442✔
35	private readonly safeAppInfoMapper: SafeAppInfoMapper,	442✔
36	) {}
37
38	async mapRichInfo(
39	transaction: MultisigTransaction \| ModuleTransaction,
40	chainId: string,
41	): Promise<RichInfo \| null> {
42	if (!transaction.data \|\| !isHex(transaction.data) \|\| !transaction.to) {	88✔
43	return null;	8✔
44	}
45
46	const sigHash = this.getSigHash(transaction.data);	80✔
47
48	if (!sigHash) return null;	80!
49
50	try {	80✔
51	const humanDescriptionFragments =
52	this.humanDescriptionRepository.getHumanDescription({	80✔
53	functionSignatureHash: sigHash,
54	to: transaction.to,
55	data: transaction.data,
56	});
57
58	const richInfoFragments = await this.enrichFragments(	8✔
59	humanDescriptionFragments,
60	transaction,
61	chainId,
62	);
63
64	const richInfo = await this.enrichSafeAppInfo(	8✔
65	richInfoFragments,
66	transaction,
67	chainId,
68	);
69
70	return {	8✔
71	fragments: richInfo,
72	};
73	} catch (error) {
74	this.loggingService.debug(	72✔
75	`Error trying to decode the input data: ${error.message}`,
76	);
77	return null;	72✔
78	}
79	}
80
81	mapHumanDescription(richInfo: RichInfo \| null): string \| null {
82	if (!richInfo?.fragments) return null;	74!
83
NEW 84	return richInfo.fragments	×
85	.map((fragment) => {
NEW 86	if (fragment.type === ValueType.TokenValue) {	×
NEW 87	return `${fragment.value} ${fragment.richData?.symbol}`;	×
88	}
89
NEW 90	return fragment.value;	×
91	})
92	.join(' ');
93	}
94
95	async enrichFragments(
96	fragments: HumanDescriptionFragment[],
97	transaction: MultisigTransaction \| ModuleTransaction,
98	chainId: string,
99	): Promise<RichInfoFragment[]> {
100	return Promise.all(	8✔
101	fragments.map(async (fragment) => {
102	switch (fragment.type) {	28✔
103	case ValueType.TokenValue:
104	return this.enrichTokenValue(fragment, transaction, chainId);	8✔
105	case ValueType.Address:
106	default:
107	return { ...fragment, richData: null };	20✔
108	}
109	}),
110	);
111	}
112
113	async enrichTokenValue(
114	fragment: TokenValueFragment,
115	transaction: MultisigTransaction \| ModuleTransaction,
116	chainId: string,
117	): Promise<RichTokenValueFragment> {
118	try {	8✔
119	const token = await this.tokenRepository.getToken({	8✔
120	chainId,
121	address: transaction.to,
122	});
123
124	let amount: string;
125	if (fragment.value.amount === MAX_UINT256) {	6✔
126	amount = 'unlimited';	2✔
127	} else if (token && token.decimals) {	4!
128	amount = formatUnits(fragment.value.amount, token.decimals);	4✔
129	} else {
NEW 130	amount = fragment.value.amount.toString();	×
131	}
132
133	return <RichTokenValueFragment>{	6✔
134	type: ValueType.TokenValue,
135	value: amount,
136	richData: {
137	symbol: token.symbol,
138	logoUri: token.logoUri,
139	},
140	};
141	} catch (error) {
142	return {	2✔
143	type: ValueType.TokenValue,
144	value: fragment.value.amount.toString(),
145	richData: {
146	symbol: null,
147	logoUri: null,
148	},
149	};
150	}
151	}
152
153	async enrichSafeAppInfo(
154	fragments: RichInfoFragment[],
155	transaction: MultisigTransaction \| ModuleTransaction,
156	chainId: string,
157	): Promise<RichInfoFragment[]> {
158	const safeAppInfo = isMultisigTransaction(transaction)	8!
159	? await this.safeAppInfoMapper.mapSafeAppInfo(chainId, transaction)
160	: null;
161
162	if (safeAppInfo) {	8✔
163	fragments.push(<RichTextFragment>{	2✔
164	type: ValueType.Text,
165	value: `via ${safeAppInfo.name}`,
166	richData: null,
167	});
168	}
169
170	return fragments;	8✔
171	}
172
173	private getSigHash(data: Hex): Hex \| null {
174	const dataStart = data.slice(0, HumanDescriptionMapper.SIG_HASH_INDEX);	80✔
175
176	return isHex(dataStart) ? dataStart : null;	80!
177	}
178	}

safe-global / safe-client-gateway / 6081449930

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