5965156534

Committed 24 Aug 2023 02:34PM UTC coverage: 92.463%. Remained the same

Build # 5965156534

Build Type

Pull #631

github

Committed by

usame-algan

Commit Message

Move getSigHash into private function

Pull Request Pull Request #631: Add human readable descriptions

Run Details

968 of 1154 branches covered (0.0%)

Branch coverage included in aggregate %.

118 of 124 new or added lines in 18 files covered. (95.16%)

4 existing lines in 1 file now uncovered.

4467 of 4724 relevant lines covered (94.56%)

71.74 hits per line

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

90.14

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

import { Hex } from 'viem/src/types/misc';
import { Inject, Injectable } from '@nestjs/common';
import { formatUnits, isAddress, isHex } from 'viem';
import { ITokenRepository } from '../../../../domain/tokens/token.repository.interface';
import { TokenRepository } from '../../../../domain/tokens/token.repository';
import { Token } from '../../../../domain/tokens/entities/token.entity';
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,
  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';

@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 mapHumanDescription(
    transaction: MultisigTransaction | ModuleTransaction,
    chainId: string,
  ): Promise<string | null> {
    if (!transaction.data || !isHex(transaction.data) || !transaction.to) {
      return null;
    }

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

    if (!sigHash) return null;

    let token: Token | null = null;
    try {
      token = await this.tokenRepository.getToken({
        chainId,
        address: transaction.to,
      });
    } catch (error) {
      this.loggingService.debug(`Error trying to get token: ${error.message}`);
    }

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

      const description = this.createHumanDescription(
        descriptionFragments,
        token,
      );

      const safeAppInfo = isMultisigTransaction(transaction)
        ? await this.safeAppInfoMapper.mapSafeAppInfo(chainId, transaction)
        : null;

      return safeAppInfo
        ? `${description} via ${safeAppInfo.name}`
        : description;
    } catch (error) {
      this.loggingService.debug(
        `Error trying to decode the input data: ${error.message}`,
      );
      return null;
    }
  }

  createHumanDescription(
    descriptionFragments: HumanDescriptionFragment[],
    token: Token | null,
  ): string {
    return descriptionFragments
      .map((fragment) => {
        switch (fragment.type) {
          case ValueType.TokenValue:
            if (!token?.decimals) return fragment.value.amount;

            // Unlimited approval
            if (fragment.value.amount === MAX_UINT256) {
              return `unlimited ${token.symbol}`;
            }

            return `${formatUnits(fragment.value.amount, token.decimals)} ${
              token.symbol
            }`;
          case ValueType.Address:
            return this.shortenAddress(fragment.value);
          default:
            return fragment.value;
        }
      })
      .join(' ');
  }

  shortenAddress(address: Hex, length = 4): string {
    if (!isAddress(address)) {
      throw Error('Invalid address');
    }

    const visibleCharactersLength = length * 2 + 2;

    if (address.length < visibleCharactersLength) {
      return address;
    }

    return `${address.slice(0, length + 2)}...${address.slice(-length)}`;
  }

  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';	33✔
3	import { formatUnits, isAddress, isHex } from 'viem';	33✔
4	import { ITokenRepository } from '../../../../domain/tokens/token.repository.interface';	33✔
5	import { TokenRepository } from '../../../../domain/tokens/token.repository';	33✔
6	import { Token } from '../../../../domain/tokens/entities/token.entity';
7	import { MAX_UINT256 } from '../../constants';	33✔
8	import {	33✔
9	ILoggingService,
10	LoggingService,
11	} from '../../../../logging/logging.interface';
12	import { IHumanDescriptionRepository } from '../../../../domain/human-description/human-description.repository.interface';	33✔
13	import { HumanDescriptionRepository } from '../../../../domain/human-description/human-description.repository';	33✔
14	import {	33✔
15	HumanDescriptionFragment,
16	ValueType,
17	} from '../../../../domain/human-description/entities/human-description.entity';
18	import { MultisigTransaction } from '../../../../domain/safe/entities/multisig-transaction.entity';
19	import { ModuleTransaction } from '../../../../domain/safe/entities/module-transaction.entity';
20	import { isMultisigTransaction } from '../../../../domain/safe/entities/transaction.entity';	33✔
21	import { SafeAppInfoMapper } from './safe-app-info.mapper';	33✔
22
23	@Injectable()
24	export class HumanDescriptionMapper {	33✔
25	private static SIG_HASH_INDEX = 10;	33✔
26
27	constructor(
28	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	214✔
29	@Inject(LoggingService) private readonly loggingService: ILoggingService,	214✔
30	@Inject(IHumanDescriptionRepository)
31	private readonly humanDescriptionRepository: HumanDescriptionRepository,	214✔
32	private readonly safeAppInfoMapper: SafeAppInfoMapper,	214✔
33	) {}
34
35	async mapHumanDescription(
36	transaction: MultisigTransaction \| ModuleTransaction,
37	chainId: string,
38	): Promise<string \| null> {
39	if (!transaction.data \|\| !isHex(transaction.data) \|\| !transaction.to) {	44✔
40	return null;	4✔
41	}
42
43	const sigHash = this.getSigHash(transaction.data);	40✔
44
45	if (!sigHash) return null;	40!
46
47	let token: Token \| null = null;	40✔
48	try {	40✔
49	token = await this.tokenRepository.getToken({	40✔
50	chainId,
51	address: transaction.to,
52	});
53	} catch (error) {
54	this.loggingService.debug(`Error trying to get token: ${error.message}`);	29✔
55	}
56
57	try {	40✔
58	const descriptionFragments =
59	this.humanDescriptionRepository.getHumanDescription({	40✔
60	functionSignatureHash: sigHash,
61	to: transaction.to,
62	data: transaction.data,
63	});
64
65	const description = this.createHumanDescription(	4✔
66	descriptionFragments,
67	token,
68	);
69
70	const safeAppInfo = isMultisigTransaction(transaction)	4!
71	? await this.safeAppInfoMapper.mapSafeAppInfo(chainId, transaction)
72	: null;
73
74	return safeAppInfo	4✔
75	? `${description} via ${safeAppInfo.name}`
76	: description;
77	} catch (error) {
78	this.loggingService.debug(	36✔
79	`Error trying to decode the input data: ${error.message}`,
80	);
81	return null;	36✔
82	}
83	}
84
85	createHumanDescription(
86	descriptionFragments: HumanDescriptionFragment[],
87	token: Token \| null,
88	): string {
89	return descriptionFragments	4✔
90	.map((fragment) => {
91	switch (fragment.type) {	14✔
92	case ValueType.TokenValue:
93	if (!token?.decimals) return fragment.value.amount;	4✔
94
95	// Unlimited approval
96	if (fragment.value.amount === MAX_UINT256) {	3✔
97	return `unlimited ${token.symbol}`;	1✔
98	}
99
100	return `${formatUnits(fragment.value.amount, token.decimals)} ${	2✔
101	token.symbol
102	}`;
103	case ValueType.Address:
104	return this.shortenAddress(fragment.value);	3✔
105	default:
106	return fragment.value;	7✔
107	}
108	})
109	.join(' ');
110	}
111
112	shortenAddress(address: Hex, length = 4): string {	6✔
113	if (!isAddress(address)) {	6!
NEW 114	throw Error('Invalid address');	×
115	}
116
117	const visibleCharactersLength = length * 2 + 2;	6✔
118
119	if (address.length < visibleCharactersLength) {	6!
NEW 120	return address;	×
121	}
122
123	return `${address.slice(0, length + 2)}...${address.slice(-length)}`;	6✔
124	}
125
126	private getSigHash(data: Hex): Hex \| null {
127	const dataStart = data.slice(0, HumanDescriptionMapper.SIG_HASH_INDEX);	40✔
128
129	return isHex(dataStart) ? dataStart : null;	40!
130	}
131	}

safe-global / safe-client-gateway-nest / 5965156534

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