5950529881

Committed 23 Aug 2023 11:09AM UTC coverage: 92.471% (+0.008%) from 92.463%

Build # 5950529881

Build Type

Pull #631

github

Committed by

usame-algan

Commit Message

fix: move safeAppInfo into human-description mapper, adjust mapper signature to accept transactions

Pull Request Pull Request #631: Add human readable descriptions

Run Details

969 of 1154 branches covered (83.97%)

Branch coverage included in aggregate %.

123 of 130 new or added lines in 18 files covered. (94.62%)

4 existing lines in 1 file now uncovered.

4472 of 4730 relevant lines covered (94.55%)

71.26 hits per line

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

90.57

/src/domain/human-description/human-description.repository.ts

import { Inject, Injectable } from '@nestjs/common';
import { IHumanDescriptionRepository } from './human-description.repository.interface';
import {
  HumanDescriptionFragment,
  HumanDescriptions,
  HumanDescriptionTemplates,
  ValueType,
} from './entities/human-description.entity';
import { IHumanDescriptionApi } from '../interfaces/human-description-api.interface';
import { getFunctionSelector, parseAbi } from 'viem';

@Injectable()
export class HumanDescriptionRepository implements IHumanDescriptionRepository {
  private readonly parsedDescriptions: HumanDescriptionTemplates;

  /**
   *  Regex Template that matches two patterns
   *  1. Double curly braces consisting of 2 groups separated by a space
   *  2. Any non-whitespace character i.e. simple words
   */
  private static readonly TEMPLATE_REGEX = /{{(.*?)\s(\$.*?)}}|(\S+)/g;

  constructor(
    @Inject(IHumanDescriptionApi)
    private readonly humanDescriptionApi: IHumanDescriptionApi,
  ) {
    const humanDescriptions = this.humanDescriptionApi.getDescriptions();
    this.parsedDescriptions = this.parseDescriptions(humanDescriptions);
  }

  getDescriptions(): HumanDescriptionTemplates {
    return this.parsedDescriptions;
  }

  parseDescriptions(
    descriptions: HumanDescriptions,
  ): HumanDescriptionTemplates {
    const templates: HumanDescriptionTemplates = {};

    for (const signature in descriptions) {
      const template = descriptions[signature];
      const sigHash = getFunctionSelector(signature);
      const abi = parseAbi([signature]);

      templates[sigHash] = {
        abi,
        process: (to: string, params: unknown[]) => {
          const fragments: HumanDescriptionFragment[] = [];

          let match: RegExpExecArray | null;

          while (
            (match =
              HumanDescriptionRepository.TEMPLATE_REGEX.exec(template)) !== null
          ) {
            const [fullMatch, valueType, valueIndexPrefixed] = match;

            if (valueType !== undefined && !this.isValueType(valueType))
              continue;

            // Matched a simple string
            if (fullMatch && !valueType && !valueIndexPrefixed) {
              fragments.push({
                type: ValueType.Word,
                value: fullMatch,
              });
              continue;
            }

            // Slice the first character of the valueIndex to remove $ prefix
            const valueIndex = valueIndexPrefixed.slice(1);

            const parsedExpression = this.parseExpression(
              valueType,
              Number(valueIndex),
              to,
              params,
            );

            if (parsedExpression) {
              fragments.push(parsedExpression);
            }
          }

          return fragments;
        },
      };
    }

    return templates;
  }

  parseExpression(
    valueType: ValueType,
    valueIndex: number,
    to: string,
    params: unknown[],
  ): HumanDescriptionFragment | null {
    try {
      const parsedParam = this.parseParam(valueType, valueIndex, to, params);

      return <HumanDescriptionFragment>{
        type: valueType,
        value: parsedParam,
      };
    } catch (error) {
      return null;
    }
  }

  parseParam(
    valueType: ValueType,
    valueIndex: number,
    to: string,
    params: unknown[],
  ): HumanDescriptionFragment['value'] {
    switch (valueType) {
      case ValueType.TokenValue:
        return {
          amount: params[valueIndex],
          address: to,
        };
      case ValueType.Address:
      case ValueType.Decimals:
      case ValueType.Identifier:
      case ValueType.Word:
        return params[valueIndex];
      default:
        throw Error(`${valueType} is not allowed as ValueType`);
    }
  }

  private isValueType(type: unknown): type is ValueType {
    return Object.values(ValueType).includes(type as ValueType);
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	33✔
2	import { IHumanDescriptionRepository } from './human-description.repository.interface';
3	import {	33✔
4	HumanDescriptionFragment,
5	HumanDescriptions,
6	HumanDescriptionTemplates,
7	ValueType,
8	} from './entities/human-description.entity';
9	import { IHumanDescriptionApi } from '../interfaces/human-description-api.interface';	33✔
10	import { getFunctionSelector, parseAbi } from 'viem';	33✔
11
12	@Injectable()
13	export class HumanDescriptionRepository implements IHumanDescriptionRepository {	33✔
14	private readonly parsedDescriptions: HumanDescriptionTemplates;
15
16	/**
17	* Regex Template that matches two patterns
18	* 1. Double curly braces consisting of 2 groups separated by a space
19	* 2. Any non-whitespace character i.e. simple words
20	*/
21	private static readonly TEMPLATE_REGEX = /{{(.?)\s(\$.?)}}\|(\S+)/g;	33✔
22
23	constructor(
24	@Inject(IHumanDescriptionApi)
25	private readonly humanDescriptionApi: IHumanDescriptionApi,	208✔
26	) {
27	const humanDescriptions = this.humanDescriptionApi.getDescriptions();	208✔
28	this.parsedDescriptions = this.parseDescriptions(humanDescriptions);	208✔
29	}
30
31	getDescriptions(): HumanDescriptionTemplates {
32	return this.parsedDescriptions;	40✔
33	}
34
35	parseDescriptions(
36	descriptions: HumanDescriptions,
37	): HumanDescriptionTemplates {
38	const templates: HumanDescriptionTemplates = {};	208✔
39
40	for (const signature in descriptions) {	208✔
41	const template = descriptions[signature];	2,496✔
42	const sigHash = getFunctionSelector(signature);	2,496✔
43	const abi = parseAbi([signature]);	2,496✔
44
45	templates[sigHash] = {	2,496✔
46	abi,
47	process: (to: string, params: unknown[]) => {
48	const fragments: HumanDescriptionFragment[] = [];	4✔
49
50	let match: RegExpExecArray \| null;
51
52	while (	4✔
53	(match =
54	HumanDescriptionRepository.TEMPLATE_REGEX.exec(template)) !== null
55	) {
56	const [fullMatch, valueType, valueIndexPrefixed] = match;	14✔
57
58	if (valueType !== undefined && !this.isValueType(valueType))	14!
NEW 59	continue;	×
60
61	// Matched a simple string
62	if (fullMatch && !valueType && !valueIndexPrefixed) {	14✔
63	fragments.push({	7✔
64	type: ValueType.Word,
65	value: fullMatch,
66	});
67	continue;	7✔
68	}
69
70	// Slice the first character of the valueIndex to remove $ prefix
71	const valueIndex = valueIndexPrefixed.slice(1);	7✔
72
73	const parsedExpression = this.parseExpression(	7✔
74	valueType,
75	Number(valueIndex),
76	to,
77	params,
78	);
79
80	if (parsedExpression) {	7✔
81	fragments.push(parsedExpression);	7✔
82	}
83	}
84
85	return fragments;	4✔
86	},
87	};
88	}
89
90	return templates;	208✔
91	}
92
93	parseExpression(
94	valueType: ValueType,
95	valueIndex: number,
96	to: string,
97	params: unknown[],
98	): HumanDescriptionFragment \| null {
99	try {	7✔
100	const parsedParam = this.parseParam(valueType, valueIndex, to, params);	7✔
101
102	return <HumanDescriptionFragment>{	7✔
103	type: valueType,
104	value: parsedParam,
105	};
106	} catch (error) {
NEW 107	return null;	×
108	}
109	}
110
111	parseParam(
112	valueType: ValueType,
113	valueIndex: number,
114	to: string,
115	params: unknown[],
116	): HumanDescriptionFragment['value'] {
117	switch (valueType) {	7!
118	case ValueType.TokenValue:
119	return {	4✔
120	amount: params[valueIndex],
121	address: to,
122	};
123	case ValueType.Address:
124	case ValueType.Decimals:
125	case ValueType.Identifier:
126	case ValueType.Word:
127	return params[valueIndex];	3✔
128	default:
NEW 129	throw Error(`${valueType} is not allowed as ValueType`);	×
130	}
131	}
132
133	private isValueType(type: unknown): type is ValueType {
134	return Object.values(ValueType).includes(type as ValueType);	7✔
135	}
136	}

safe-global / safe-client-gateway-nest / 5950529881

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