10811684306

Committed 11 Sep 2024 12:31PM UTC coverage: 90.785% (-0.2%) from 90.937%

Build # 10811684306

Build Type

Pull #1913

github

Committed by

web-flow

Commit Message

Merge be4a3f5f2 into dd4018bfc

Pull Request Pull Request #1913: Get claimable rewards from transaction data

Run Details

2605 of 3243 branches covered (80.33%)

Branch coverage included in aggregate %.

35 of 37 new or added lines in 7 files covered. (94.59%)

54 existing lines in 3 files now uncovered.

8271 of 8737 relevant lines covered (94.67%)

442.34 hits per line

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

67.39

/src/domain/staking/contracts/decoders/kiln-decoder.helper.ts

import { AbiDecoder } from '@/domain/contracts/decoders/abi-decoder.helper';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';
import { Inject, Injectable } from '@nestjs/common';

export const KilnAbi = [
  {
    inputs: [],
    name: 'deposit',
    outputs: [],
    stateMutability: 'payable',
    type: 'function',
  },
  {
    inputs: [{ internalType: 'bytes', name: '_publicKeys', type: 'bytes' }],
    name: 'requestValidatorsExit',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [{ internalType: 'bytes', name: '_publicKeys', type: 'bytes' }],
    name: 'batchWithdrawCLFee',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
] as const;

export type KilnRequestValidatorsExitParameters = {
  name: '_publicKeys';
  type: 'bytes';
  value: `0x${string}`;
  valueDecoded: null;
};
export type KilnBatchWithdrawCLFeeParameters =
  KilnRequestValidatorsExitParameters;

@Injectable()
export class KilnDecoder extends AbiDecoder<typeof KilnAbi> {
  constructor(
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {
    super(KilnAbi);
  }

  decodeDeposit(
    data: `0x${string}`,
  ): { method: string; parameters: [] } | null {
    if (!this.helpers.isDeposit(data)) {
      return null;
    }
    try {
      const decoded = this.decodeFunctionData({ data });
      if (decoded.functionName !== 'deposit') {
        throw new Error('Data is not of deposit type');
      }
      return {
        method: decoded.functionName,
        parameters: [],
      };
    } catch (e) {
      this.loggingService.debug(e);
      return null;
    }
  }

  decodeValidatorsExit(data: `0x${string}`): {
    method: string;
    parameters: KilnRequestValidatorsExitParameters[];
  } | null {
    if (!this.helpers.isRequestValidatorsExit(data)) {
      return null;
    }
    try {
      const decoded = this.decodeFunctionData({ data });
      if (decoded.functionName !== 'requestValidatorsExit') {
        throw new Error('Data is not of requestValidatorsExit type');
      }
      return {
        method: decoded.functionName,
        parameters: [
          {
            name: '_publicKeys',
            type: 'bytes',
            value: decoded.args[0],
            valueDecoded: null,
          },
        ],
      };
    } catch (e) {
      this.loggingService.debug(e);
      return null;
    }
  }

  decodeBatchWithdrawCLFee(data: `0x${string}`): {
    method: string;
    parameters: KilnBatchWithdrawCLFeeParameters[];
  } | null {
    if (!this.helpers.isBatchWithdrawCLFee(data)) {
      return null;
    }
    try {
      const decoded = this.decodeFunctionData({ data });
      if (decoded.functionName !== 'batchWithdrawCLFee') {
        throw new Error('Data is not of batchWithdrawCLFee type');
      }
      return {
        method: decoded.functionName,
        parameters: [
          {
            name: '_publicKeys',
            type: 'bytes',
            value: decoded.args[0],
            valueDecoded: null,
          },
        ],
      };
    } catch (e) {
      this.loggingService.debug(e);
      return null;
    }
  }
}

1	import { AbiDecoder } from '@/domain/contracts/decoders/abi-decoder.helper';	98✔
2	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	98✔
3	import { Inject, Injectable } from '@nestjs/common';	98✔
4
5	export const KilnAbi = [	98✔
6	{
7	inputs: [],
8	name: 'deposit',
9	outputs: [],
10	stateMutability: 'payable',
11	type: 'function',
12	},
13	{
14	inputs: [{ internalType: 'bytes', name: '_publicKeys', type: 'bytes' }],
15	name: 'requestValidatorsExit',
16	outputs: [],
17	stateMutability: 'nonpayable',
18	type: 'function',
19	},
20	{
21	inputs: [{ internalType: 'bytes', name: '_publicKeys', type: 'bytes' }],
22	name: 'batchWithdrawCLFee',
23	outputs: [],
24	stateMutability: 'nonpayable',
25	type: 'function',
26	},
27	] as const;
28
29	export type KilnRequestValidatorsExitParameters = {
30	name: '_publicKeys';
31	type: 'bytes';
32	value: `0x${string}`;
33	valueDecoded: null;
34	};
35	export type KilnBatchWithdrawCLFeeParameters =
36	KilnRequestValidatorsExitParameters;
37
38	@Injectable()
39	export class KilnDecoder extends AbiDecoder<typeof KilnAbi> {	98✔
40	constructor(
41	@Inject(LoggingService) private readonly loggingService: ILoggingService,	80✔
42	) {
43	super(KilnAbi);	80✔
44	}
45
46	decodeDeposit(
47	data: `0x${string}`,
48	): { method: string; parameters: [] } \| null {
49	if (!this.helpers.isDeposit(data)) {	8✔
50	return null;	4✔
51	}
52	try {	4✔
53	const decoded = this.decodeFunctionData({ data });	4✔
54	if (decoded.functionName !== 'deposit') {	4!
UNCOV 55	throw new Error('Data is not of deposit type');	×
56	}
57	return {	4✔
58	method: decoded.functionName,
59	parameters: [],
60	};
61	} catch (e) {
UNCOV 62	this.loggingService.debug(e);	×
63	return null;	×
64	}
65	}
66
67	decodeValidatorsExit(data: `0x${string}`): {
68	method: string;
69	parameters: KilnRequestValidatorsExitParameters[];
70	} \| null {
71	if (!this.helpers.isRequestValidatorsExit(data)) {	8✔
72	return null;	4✔
73	}
74	try {	4✔
75	const decoded = this.decodeFunctionData({ data });	4✔
76	if (decoded.functionName !== 'requestValidatorsExit') {	4!
UNCOV 77	throw new Error('Data is not of requestValidatorsExit type');	×
78	}
79	return {	4✔
80	method: decoded.functionName,
81	parameters: [
82	{
83	name: '_publicKeys',
84	type: 'bytes',
85	value: decoded.args[0],
86	valueDecoded: null,
87	},
88	],
89	};
90	} catch (e) {
UNCOV 91	this.loggingService.debug(e);	×
92	return null;	×
93	}
94	}
95
96	decodeBatchWithdrawCLFee(data: `0x${string}`): {
97	method: string;
98	parameters: KilnBatchWithdrawCLFeeParameters[];
99	} \| null {
100	if (!this.helpers.isBatchWithdrawCLFee(data)) {	8✔
101	return null;	4✔
102	}
103	try {	4✔
104	const decoded = this.decodeFunctionData({ data });	4✔
105	if (decoded.functionName !== 'batchWithdrawCLFee') {	4!
UNCOV 106	throw new Error('Data is not of batchWithdrawCLFee type');	×
107	}
108	return {	4✔
109	method: decoded.functionName,
110	parameters: [
111	{
112	name: '_publicKeys',
113	type: 'bytes',
114	value: decoded.args[0],
115	valueDecoded: null,
116	},
117	],
118	};
119	} catch (e) {
UNCOV 120	this.loggingService.debug(e);	×
121	return null;	×
122	}
123	}
124	}

safe-global / safe-client-gateway / 10811684306

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