11031317793

Committed 25 Sep 2024 10:37AM UTC coverage: 90.796% (+0.003%) from 90.793%

Build # 11031317793

Build Type

Pull #1957

github

Committed by

iamacook

Commit Message

Merge branch 'main' into deposit-status

Pull Request Pull Request #1957: Get public keys from `DepositEvent`

Run Details

2557 of 3187 branches covered (80.23%)

Branch coverage included in aggregate %.

26 of 29 new or added lines in 2 files covered. (89.66%)

1 existing line in 1 file now uncovered.

8363 of 8840 relevant lines covered (94.6%)

445.48 hits per line

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

68.42

/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';
import { parseAbi } from 'viem';

export const KilnAbi = parseAbi([
  'event DepositEvent(bytes pubkey, bytes withdrawal_credentials, bytes amount, bytes signature, bytes index)',
  'function deposit()',
  'function requestValidatorsExit(bytes _publicKeys)',
  'function batchWithdrawCLFee(bytes _publicKeys)',
]);

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

@Injectable()
export class KilnDecoder extends AbiDecoder<typeof KilnAbi> {
  public static readonly KilnPublicKeyLength = 96;
  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;
    }
  }

  decodeDepositEvent(args: {
    data: `0x${string}`;
    topics: [signature: `0x${string}`, ...args: `0x${string}`[]];
  }): {
    pubkey: `0x${string}`;
    withdrawal_credentials: `0x${string}`;
    amount: `0x${string}`;
    signature: `0x${string}`;
    index: `0x${string}`;
  } | null {
    try {
      const decoded = this.decodeEventLog(args);
      if (decoded.eventName !== 'DepositEvent') {
        throw new Error('Data is not of DepositEvent type');
      }
      return decoded.args;
    } catch (e) {
      this.loggingService.debug(e);
      return null;
    }
  }
}

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

safe-global / safe-client-gateway / 11031317793

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