8250994590

Committed 12 Mar 2024 02:55PM UTC coverage: 93.388% (-0.01%) from 93.399%

Build # 8250994590

Build Type

Pull #1282

github

Committed by

hectorgomezv

Commit Message

Cast to SafeRegExpMatchArray type

Pull Request Pull Request #1282: build(deps-dev): bump typescript from 5.3.3 to 5.4.2

Run Details

1767 of 2124 branches covered (83.19%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

8 existing lines in 1 file now uncovered.

6354 of 6572 relevant lines covered (96.68%)

343.64 hits per line

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

66.67

/src/domain/human-description/entities/human-description-template.entity.ts

import { decodeFunctionData, isHex, parseAbi } from 'viem';
import {
  HumanDescriptionFragment,
  TextFragment,
  ValueType,
} from '@/domain/human-description/entities/human-description.entity';

type SafeRegExpMatchArray = RegExpMatchArray & {
  groups: NonNullable<RegExpMatchArray['groups']>;
};

/**
 * A {@link HumanDescriptionTemplate} represents a human-readable template
 *
 * The template requires a function signature in a string format and the
 * respective human-readable template.
 *
 * Creating a new {@link HumanDescriptionTemplate} triggers the ABI parsing
 * for the function signature, which can be an expensive operation.
 */
export class HumanDescriptionTemplate {
  private readonly functionAbi: never;

  private static readonly REGEX =
    /{{(?<typeToken>\w+) \$(?<paramIndex>\d+)}}|(?<textToken>\w+)/g;

  /**
   * Store the regex matches as an array instead of an iterable so that it can be restarted
   * @private
   */
  private readonly templateMatches: SafeRegExpMatchArray[];

  constructor(
    functionSignature: string,
    private readonly template: string,
  ) {
    this.functionAbi = parseAbi([functionSignature]);

    this.templateMatches = Array.from(
      template.matchAll(HumanDescriptionTemplate.REGEX),
    ).filter((match) => match.groups !== undefined) as SafeRegExpMatchArray[];
  }

  /**
   * Parses a hex-data string into an array of {@link HumanDescriptionFragment}
   *
   * The resulting array represents the human-readable message in-order i.e.;
   * the first index represents the first word, second index the second word, etc.
   *
   * @param to - the target address of the transaction
   * @param data - the raw data of the transaction
   */
  parse(to: string, data: `0x${string}`): HumanDescriptionFragment[] {
    const { args } = decodeFunctionData({
      abi: this.functionAbi,
      data,
    });

    const fragments: HumanDescriptionFragment[] = [];

    for (const match of this.templateMatches) {
      if ('textToken' in match.groups && match.groups.textToken !== undefined) {
        const textFragment: TextFragment = {
          type: ValueType.Text,
          value: match.groups.textToken,
        };
        fragments.push(textFragment);
      } else if (
        'typeToken' in match.groups &&
        'paramIndex' in match.groups &&
        match.groups.typeToken !== undefined &&
        match.groups.paramIndex !== undefined
      ) {
        const tokenType = match.groups.typeToken;
        const paramIndex = match.groups.paramIndex;

        if (!args) {
          throw Error(
            `Error mapping token type ${tokenType}. No arguments provided`,
          );
        }

        fragments.push(
          this._mapTokenType(to, tokenType, Number(paramIndex), args),
        );
      } else {
        throw Error(`Error parsing template ${this.template}`);
      }
    }

    return fragments;
  }

  private _mapTokenType(
    to: string,
    tokenType: string,
    index: number,
    args: readonly unknown[],
  ): HumanDescriptionFragment {
    const value = args[index];

    switch (tokenType) {
      case ValueType.TokenValue: {
        if (typeof value !== 'bigint') {
          throw Error(
            `Invalid token type amount. tokenType=${tokenType}, amount=${value}`,
          );
        }

        return {
          type: ValueType.TokenValue,
          value: { amount: value, address: to },
        };
      }
      case ValueType.Address: {
        if (!isHex(value)) {
          throw Error(
            `Invalid token type value. tokenType=${tokenType}, address=${value}`,
          );
        }

        return {
          type: ValueType.Address,
          value,
        };
      }
      case ValueType.Number: {
        if (typeof value !== 'bigint') {
          throw Error(
            `Invalid token type value. tokenType=${tokenType}, address=${value}`,
          );
        }

        return {
          type: ValueType.Number,
          value,
        };
      }
      default: {
        throw Error(`Unknown token type ${tokenType}`);
      }
    }
  }
}

1	import { decodeFunctionData, isHex, parseAbi } from 'viem';	98✔
2	import {	98✔
3	HumanDescriptionFragment,
4	TextFragment,
5	ValueType,
6	} from '@/domain/human-description/entities/human-description.entity';
7
8	type SafeRegExpMatchArray = RegExpMatchArray & {
9	groups: NonNullable<RegExpMatchArray['groups']>;
10	};
11
12	/**
13	* A {@link HumanDescriptionTemplate} represents a human-readable template
14	*
15	* The template requires a function signature in a string format and the
16	* respective human-readable template.
17	*
18	* Creating a new {@link HumanDescriptionTemplate} triggers the ABI parsing
19	* for the function signature, which can be an expensive operation.
20	*/
21	export class HumanDescriptionTemplate {	98✔
22	private readonly functionAbi: never;
23
24	private static readonly REGEX =	98✔
25	/{{(?<typeToken>\w+) \$(?<paramIndex>\d+)}}\|(?<textToken>\w+)/g;
26
27	/**
28	* Store the regex matches as an array instead of an iterable so that it can be restarted
29	* @private
30	*/
31	private readonly templateMatches: SafeRegExpMatchArray[];
32
33	constructor(
34	functionSignature: string,
35	private readonly template: string,	13,152✔
36	) {
37	this.functionAbi = parseAbi([functionSignature]);	13,152✔
38
39	this.templateMatches = Array.from(	13,152✔
40	template.matchAll(HumanDescriptionTemplate.REGEX),
41	).filter((match) => match.groups !== undefined) as SafeRegExpMatchArray[];	51,512✔
42	}
43
44	/**
45	* Parses a hex-data string into an array of {@link HumanDescriptionFragment}
46	*
47	* The resulting array represents the human-readable message in-order i.e.;
48	* the first index represents the first word, second index the second word, etc.
49	*
50	* @param to - the target address of the transaction
51	* @param data - the raw data of the transaction
52	*/
53	parse(to: string, data: `0x${string}`): HumanDescriptionFragment[] {
54	const { args } = decodeFunctionData({	10✔
55	abi: this.functionAbi,
56	data,
57	});
58
59	const fragments: HumanDescriptionFragment[] = [];	8✔
60
61	for (const match of this.templateMatches) {	8✔
62	if ('textToken' in match.groups && match.groups.textToken !== undefined) {	28✔
63	const textFragment: TextFragment = {	14✔
64	type: ValueType.Text,
65	value: match.groups.textToken,
66	};
67	fragments.push(textFragment);	14✔
68	} else if (	14!
69	'typeToken' in match.groups &&	28✔
70	'paramIndex' in match.groups &&
71	match.groups.typeToken !== undefined &&
72	match.groups.paramIndex !== undefined
73	) {
74	const tokenType = match.groups.typeToken;	14✔
75	const paramIndex = match.groups.paramIndex;	14✔
76
77	if (!args) {	14!
UNCOV 78	throw Error(	×
79	`Error mapping token type ${tokenType}. No arguments provided`,
80	);
81	}
82
83	fragments.push(	14✔
84	this._mapTokenType(to, tokenType, Number(paramIndex), args),
85	);
86	} else {
UNCOV 87	throw Error(`Error parsing template ${this.template}`);	×
88	}
89	}
90
91	return fragments;	8✔
92	}
93
94	private _mapTokenType(
95	to: string,
96	tokenType: string,
97	index: number,
98	args: readonly unknown[],
99	): HumanDescriptionFragment {
100	const value = args[index];	14✔
101
102	switch (tokenType) {	14!
103	case ValueType.TokenValue: {
104	if (typeof value !== 'bigint') {	8!
UNCOV 105	throw Error(	×
106	`Invalid token type amount. tokenType=${tokenType}, amount=${value}`,
107	);
108	}
109
110	return {	8✔
111	type: ValueType.TokenValue,
112	value: { amount: value, address: to },
113	};
114	}
115	case ValueType.Address: {
116	if (!isHex(value)) {	6!
UNCOV 117	throw Error(	×
118	`Invalid token type value. tokenType=${tokenType}, address=${value}`,
119	);
120	}
121
122	return {	6✔
123	type: ValueType.Address,
124	value,
125	};
126	}
127	case ValueType.Number: {
UNCOV 128	if (typeof value !== 'bigint') {	×
UNCOV 129	throw Error(	×
130	`Invalid token type value. tokenType=${tokenType}, address=${value}`,
131	);
132	}
133
UNCOV 134	return {	×
135	type: ValueType.Number,
136	value,
137	};
138	}
139	default: {
UNCOV 140	throw Error(`Unknown token type ${tokenType}`);	×
141	}
142	}
143	}
144	}

safe-global / safe-client-gateway / 8250994590

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