6039635439

Committed 31 Aug 2023 03:54PM UTC coverage: 91.727% (-0.3%) from 92.001%

Build # 6039635439

Build Type

push

github

Committed by

fmrsabino

Commit Message

wip

Run Details

980 of 1188 branches covered (0.0%)

Branch coverage included in aggregate %.

13 of 16 new or added lines in 4 files covered. (81.25%)

5 existing lines in 1 file now uncovered.

4564 of 4856 relevant lines covered (93.99%)

72.74 hits per line

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

52.17

/src/domain/relay/safe-contract.ts

import { Injectable } from '@nestjs/common';
import { getSafeSingletonDeployment } from '@safe-global/safe-deployments';
import { Abi, decodeFunctionData, isHex } from 'viem';
import { Hex } from 'viem/src/types/misc';

interface SafeFunction<B> {
  name: string;
  mapper: (args: readonly unknown[]) => B;
}

export class ExecTransaction
  implements
    SafeFunction<{
      data: Hex;
      to: Hex;
      value: bigint;
    }>
{
  name = 'execTransaction';

  mapper(args: readonly unknown[]): { data: Hex; to: Hex; value: bigint } {
    if (!isHex(args[2]) || !isHex(args[0]) || typeof args[1] !== 'bigint')
      throw Error('foo');
    return { data: args[2], to: args[0], value: args[1] };
  }
}

@Injectable({})
export class SafeContract {
  private readonly abi: Abi;

  private static SUPPORTED_SAFE_VERSION = '1.3.0';

  private safeFunction = {
    execTransaction: {
      mapper: (args: readonly unknown[]) =>
        <{ data: Hex; to: Hex; value: bigint }>{
          data: args[2],
          to: args[0],
          value: args[1],
        },
    },
  };

  constructor() {
    const safeDeployment = getSafeSingletonDeployment({
      version: SafeContract.SUPPORTED_SAFE_VERSION,
    });
    if (!safeDeployment) throw Error('Safe deployment is undefined');
    this.abi = safeDeployment.abi;
  }

  isSafeCall(data: Hex): boolean {
    try {
      decodeFunctionData({
        abi: this.abi,
        data,
      });
    } catch (e) {
      console.error(e);
      return false;
    }

    return true;
  }

  decode<B>(safeFunction: SafeFunction<B>, data: Hex): B {
    const { functionName, args } = decodeFunctionData({
      abi: this.abi,
      data,
    });

    if (safeFunction.name != functionName || !args)
      throw Error(`Provided data is not a call to ${safeFunction.name}`);

    return safeFunction.mapper(args);
  }

  decodeExecTransaction(data: Hex): { data: Hex; to: Hex; value: bigint } {
    const { functionName, args } = decodeFunctionData({
      abi: this.abi,
      data,
    });

    if (functionName != 'execTransaction' || !args)
      throw Error('Provided data is not an execTransaction call');

    const [txTo, txValue, txData] = args;

    if (!isHex(txTo) || typeof txValue !== 'bigint' || !isHex(txData))
      throw Error('Unexpected types for args');

    return {
      to: txTo,
      value: txValue,
      data: txData,
    };
  }
}

1	import { Injectable } from '@nestjs/common';	26✔
2	import { getSafeSingletonDeployment } from '@safe-global/safe-deployments';	26✔
3	import { Abi, decodeFunctionData, isHex } from 'viem';	26✔
4	import { Hex } from 'viem/src/types/misc';
5
6	interface SafeFunction<B> {
7	name: string;
8	mapper: (args: readonly unknown[]) => B;
9	}
10
11	export class ExecTransaction	26✔
12	implements
13	SafeFunction<{
14	data: Hex;
15	to: Hex;
16	value: bigint;
17	}>
18	{
19	name = 'execTransaction';	1✔
20
21	mapper(args: readonly unknown[]): { data: Hex; to: Hex; value: bigint } {
22	if (!isHex(args[2]) \|\| !isHex(args[0]) \|\| typeof args[1] !== 'bigint')	1!
NEW 23	throw Error('foo');	×
24	return { data: args[2], to: args[0], value: args[1] };	1✔
25	}
26	}
27
28	@Injectable({})
29	export class SafeContract {	26✔
30	private readonly abi: Abi;
31
32	private static SUPPORTED_SAFE_VERSION = '1.3.0';	26✔
33
34	private safeFunction = {	201✔
35	execTransaction: {
36	mapper: (args: readonly unknown[]) =>
NEW 37	<{ data: Hex; to: Hex; value: bigint }>{	×
38	data: args[2],
39	to: args[0],
40	value: args[1],
41	},
42	},
43	};
44
45	constructor() {
46	const safeDeployment = getSafeSingletonDeployment({	201✔
47	version: SafeContract.SUPPORTED_SAFE_VERSION,
48	});
49	if (!safeDeployment) throw Error('Safe deployment is undefined');	201!
50	this.abi = safeDeployment.abi;	201✔
51	}
52
53	isSafeCall(data: Hex): boolean {
54	try {	1✔
55	decodeFunctionData({	1✔
56	abi: this.abi,
57	data,
58	});
59	} catch (e) {
60	console.error(e);	×
61	return false;	×
62	}
63
64	return true;	1✔
65	}
66
67	decode<B>(safeFunction: SafeFunction<B>, data: Hex): B {
68	const { functionName, args } = decodeFunctionData({	1✔
69	abi: this.abi,
70	data,
71	});
72
73	if (safeFunction.name != functionName \|\| !args)	1!
NEW 74	throw Error(`Provided data is not a call to ${safeFunction.name}`);	×
75
76	return safeFunction.mapper(args);	1✔
77	}
78
79	decodeExecTransaction(data: Hex): { data: Hex; to: Hex; value: bigint } {
UNCOV 80	const { functionName, args } = decodeFunctionData({	×
81	abi: this.abi,
82	data,
83	});
84
UNCOV 85	if (functionName != 'execTransaction' \|\| !args)	×
86	throw Error('Provided data is not an execTransaction call');	×
87
UNCOV 88	const [txTo, txValue, txData] = args;	×
89
UNCOV 90	if (!isHex(txTo) \|\| typeof txValue !== 'bigint' \|\| !isHex(txData))	×
91	throw Error('Unexpected types for args');	×
92
UNCOV 93	return {	×
94	to: txTo,
95	value: txValue,
96	data: txData,
97	};
98	}
99	}

safe-global / safe-client-gateway / 6039635439

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