10195057817

Committed 01 Aug 2024 08:44AM UTC coverage: 77.973% (-0.06%) from 78.033%

Build # 10195057817

Build Type

Pull #887

github

Committed by

web-flow

Commit Message

Merge 9853b121b into fbc495715

Pull Request Pull Request #887: feat: Viem migration

Run Details

256 of 402 branches covered (63.68%)

Branch coverage included in aggregate %.

75 of 88 new or added lines in 14 files covered. (85.23%)

9 existing lines in 3 files now uncovered.

944 of 1137 relevant lines covered (83.03%)

3.04 hits per line

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

81.25

/packages/relay-kit/src/packs/safe-4337/utils.ts

import {
  Address,
  Hex,
  createPublicClient,
  encodeFunctionData,
  encodePacked,
  hashTypedData,
  http,
  rpcSchema,
  toHex
} from 'viem'
import {
  SafeUserOperation,
  OperationType,
  MetaTransactionData,
  SafeSignature,
  UserOperation
} from '@safe-global/safe-core-sdk-types'
import {
  EthSafeSignature,
  SafeProvider,
  encodeMultiSendData,
  buildSignatureBytes
} from '@safe-global/protocol-kit'
import { ABI, EIP712_SAFE_OPERATION_TYPE } from './constants'
import { BundlerClient, PimlicoCustomRpcSchema } from './types'

/**
 * Gets the EIP-4337 bundler provider.
 *
 * @param {string} bundlerUrl The EIP-4337 bundler URL.
 * @return {BundlerClient} The EIP-4337 bundler provider.
 */
export function getEip4337BundlerProvider(bundlerUrl: string): BundlerClient {
  const provider = createPublicClient({
    transport: http(bundlerUrl),
    rpcSchema: rpcSchema<[...PimlicoCustomRpcSchema]>()
  })

  return provider
}

/**
 * Signs typed data.
 *
 * @param {SafeUserOperation} safeUserOperation - Safe user operation to sign.
 * @param {SafeProvider} safeProvider - Safe provider.
 * @param {string} safe4337ModuleAddress - Safe 4337 module address.
 * @return {Promise<SafeSignature>} The SafeSignature object containing the data and the signatures.
 */
export async function signSafeOp(
  safeUserOperation: SafeUserOperation,
  safeProvider: SafeProvider,
  safe4337ModuleAddress: string
): Promise<SafeSignature> {
  const signer = await safeProvider.getExternalSigner()

  if (!signer) {
    throw new Error('No signer found')
  }

  const chainId = await safeProvider.getChainId()
  const signerAddress = await signer.account.address
  const signature = await signer.signTypedData({
    domain: {
      chainId: Number(chainId),
      verifyingContract: safe4337ModuleAddress as Address
    },
    types: EIP712_SAFE_OPERATION_TYPE,
    message: {
      ...safeUserOperation,
      nonce: toHex(safeUserOperation.nonce),
      validAfter: toHex(safeUserOperation.validAfter),
      validUntil: toHex(safeUserOperation.validUntil),
      maxFeePerGas: toHex(safeUserOperation.maxFeePerGas),
      maxPriorityFeePerGas: toHex(safeUserOperation.maxPriorityFeePerGas)
    },
    primaryType: 'SafeOp'
  })

  return new EthSafeSignature(signerAddress, signature)
}

/**
 * Encodes multi-send data from transactions batch.
 *
 * @param {MetaTransactionData[]} transactions - an array of transaction to to be encoded.
 * @return {string} The encoded data string.
 */
export function encodeMultiSendCallData(transactions: MetaTransactionData[]): string {
  return encodeFunctionData({
    abi: ABI,
    functionName: 'multiSend',
    args: [
      encodeMultiSendData(
        transactions.map((tx) => ({ ...tx, operation: tx.operation ?? OperationType.Call }))
      ) as Hex
    ]
  })
}

/**
 * Gets the safe user operation hash.
 *
 * @param {SafeUserOperation} safeUserOperation - The SafeUserOperation.
 * @param {bigint} chainId - The chain id.
 * @param {string} safe4337ModuleAddress - The Safe 4337 module address.
 * @return {string} The hash of the safe operation.
 */
export function calculateSafeUserOperationHash(
  safeUserOperation: SafeUserOperation,
  chainId: bigint,
  safe4337ModuleAddress: string
): string {
  return hashTypedData({
    domain: {
      chainId: Number(chainId),
      verifyingContract: safe4337ModuleAddress as Address
    },
    types: EIP712_SAFE_OPERATION_TYPE,
    primaryType: 'SafeOp',
    message: safeUserOperation
  })
}

/**
 * Converts various bigint values from a UserOperation to their hexadecimal representation.
 *
 * @param {UserOperation} userOperation - The UserOperation object whose values are to be converted.
 * @returns {UserOperation} A new UserOperation object with the values converted to hexadecimal.
 */
export function userOperationToHexValues(userOperation: UserOperation) {
  const userOperationWithHexValues = {
    ...userOperation,
    nonce: toHex(BigInt(userOperation.nonce)),
    callGasLimit: toHex(userOperation.callGasLimit),
    verificationGasLimit: toHex(userOperation.verificationGasLimit),
    preVerificationGas: toHex(userOperation.preVerificationGas),
    maxFeePerGas: toHex(userOperation.maxFeePerGas),
    maxPriorityFeePerGas: toHex(userOperation.maxPriorityFeePerGas)
  }

  return userOperationWithHexValues
}

/**
 * This method creates a dummy signature for the SafeOperation based the owners.
 * This is useful for gas estimations
 * @param userOperation - The user operation
 * @param safeOwners - The safe owner addresses
 * @returns The user operation with the dummy signature
 */
export function addDummySignature(
  userOperation: UserOperation,
  safeOwners: string[]
): UserOperation {
  const signatures = []

  for (const owner of safeOwners) {
    const dummySignature = `0x000000000000000000000000${owner.slice(2)}000000000000000000000000000000000000000000000000000000000000000001`
    signatures.push(new EthSafeSignature(owner, dummySignature))
  }

  return {
    ...userOperation,
    signature: encodePacked(
      ['uint48', 'uint48', 'bytes'],
      [0, 0, buildSignatureBytes(signatures) as Hex]
    )
  }
}

1	import {	3✔
2	Address,
3	Hex,
4	createPublicClient,
5	encodeFunctionData,
6	encodePacked,
7	hashTypedData,
8	http,
9	rpcSchema,
10	toHex
11	} from 'viem'
12	import {	3✔
13	SafeUserOperation,
14	OperationType,
15	MetaTransactionData,
16	SafeSignature,
17	UserOperation
18	} from '@safe-global/safe-core-sdk-types'
19	import {	3✔
20	EthSafeSignature,
21	SafeProvider,
22	encodeMultiSendData,
23	buildSignatureBytes
24	} from '@safe-global/protocol-kit'
25	import { ABI, EIP712_SAFE_OPERATION_TYPE } from './constants'	3✔
26	import { BundlerClient, PimlicoCustomRpcSchema } from './types'
27
28	/**
29	* Gets the EIP-4337 bundler provider.
30	*
31	* @param {string} bundlerUrl The EIP-4337 bundler URL.
32	* @return {BundlerClient} The EIP-4337 bundler provider.
33	*/
34	export function getEip4337BundlerProvider(bundlerUrl: string): BundlerClient {	3✔
NEW 35	const provider = createPublicClient({	×
36	transport: http(bundlerUrl),
37	rpcSchema: rpcSchema<[...PimlicoCustomRpcSchema]>()
38	})
39
UNCOV 40	return provider	×
41	}
42
43	/**
44	* Signs typed data.
45	*
46	* @param {SafeUserOperation} safeUserOperation - Safe user operation to sign.
47	* @param {SafeProvider} safeProvider - Safe provider.
48	* @param {string} safe4337ModuleAddress - Safe 4337 module address.
49	* @return {Promise<SafeSignature>} The SafeSignature object containing the data and the signatures.
50	*/
51	export async function signSafeOp(	3✔
52	safeUserOperation: SafeUserOperation,
53	safeProvider: SafeProvider,
54	safe4337ModuleAddress: string
55	): Promise<SafeSignature> {
56	const signer = await safeProvider.getExternalSigner()	3✔
57
58	if (!signer) {	3!
NEW 59	throw new Error('No signer found')	×
60	}
61
62	const chainId = await safeProvider.getChainId()	3✔
63	const signerAddress = await signer.account.address	3✔
64	const signature = await signer.signTypedData({	3✔
65	domain: {
66	chainId: Number(chainId),
67	verifyingContract: safe4337ModuleAddress as Address
68	},
69	types: EIP712_SAFE_OPERATION_TYPE,
70	message: {
71	...safeUserOperation,
72	nonce: toHex(safeUserOperation.nonce),
73	validAfter: toHex(safeUserOperation.validAfter),
74	validUntil: toHex(safeUserOperation.validUntil),
75	maxFeePerGas: toHex(safeUserOperation.maxFeePerGas),
76	maxPriorityFeePerGas: toHex(safeUserOperation.maxPriorityFeePerGas)
77	},
78	primaryType: 'SafeOp'
79	})
80
81	return new EthSafeSignature(signerAddress, signature)	3✔
82	}
83
84	/**
85	* Encodes multi-send data from transactions batch.
86	*
87	* @param {MetaTransactionData[]} transactions - an array of transaction to to be encoded.
88	* @return {string} The encoded data string.
89	*/
90	export function encodeMultiSendCallData(transactions: MetaTransactionData[]): string {	3✔
91	return encodeFunctionData({	2✔
92	abi: ABI,
93	functionName: 'multiSend',
94	args: [
95	encodeMultiSendData(
96	transactions.map((tx) => ({ ...tx, operation: tx.operation ?? OperationType.Call }))	4!
97	) as Hex
98	]
99	})
100	}
101
102	/**
103	* Gets the safe user operation hash.
104	*
105	* @param {SafeUserOperation} safeUserOperation - The SafeUserOperation.
106	* @param {bigint} chainId - The chain id.
107	* @param {string} safe4337ModuleAddress - The Safe 4337 module address.
108	* @return {string} The hash of the safe operation.
109	*/
110	export function calculateSafeUserOperationHash(	3✔
111	safeUserOperation: SafeUserOperation,
112	chainId: bigint,
113	safe4337ModuleAddress: string
114	): string {
NEW 115	return hashTypedData({	×
116	domain: {
117	chainId: Number(chainId),
118	verifyingContract: safe4337ModuleAddress as Address
119	},
120	types: EIP712_SAFE_OPERATION_TYPE,
121	primaryType: 'SafeOp',
122	message: safeUserOperation
123	})
124	}
125
126	/**
127	* Converts various bigint values from a UserOperation to their hexadecimal representation.
128	*
129	* @param {UserOperation} userOperation - The UserOperation object whose values are to be converted.
130	* @returns {UserOperation} A new UserOperation object with the values converted to hexadecimal.
131	*/
132	export function userOperationToHexValues(userOperation: UserOperation) {	3✔
133	const userOperationWithHexValues = {	14✔
134	...userOperation,
135	nonce: toHex(BigInt(userOperation.nonce)),
136	callGasLimit: toHex(userOperation.callGasLimit),
137	verificationGasLimit: toHex(userOperation.verificationGasLimit),
138	preVerificationGas: toHex(userOperation.preVerificationGas),
139	maxFeePerGas: toHex(userOperation.maxFeePerGas),
140	maxPriorityFeePerGas: toHex(userOperation.maxPriorityFeePerGas)
141	}
142
143	return userOperationWithHexValues	14✔
144	}
145
146	/**
147	* This method creates a dummy signature for the SafeOperation based the owners.
148	* This is useful for gas estimations
149	* @param userOperation - The user operation
150	* @param safeOwners - The safe owner addresses
151	* @returns The user operation with the dummy signature
152	*/
153	export function addDummySignature(	3✔
154	userOperation: UserOperation,
155	safeOwners: string[]
156	): UserOperation {
157	const signatures = []	8✔
158
159	for (const owner of safeOwners) {	8✔
160	const dummySignature = `0x000000000000000000000000${owner.slice(2)}000000000000000000000000000000000000000000000000000000000000000001`	8✔
161	signatures.push(new EthSafeSignature(owner, dummySignature))	8✔
162	}
163
164	return {	8✔
165	...userOperation,
166	signature: encodePacked(
167	['uint48', 'uint48', 'bytes'],
168	[0, 0, buildSignatureBytes(signatures) as Hex]
169	)
170	}
171	}

safe-global / safe-core-sdk / 10195057817

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