9697300982

Committed 27 Jun 2024 01:15PM UTC coverage: 77.786% (+0.08%) from 77.708%

Build # 9697300982

Build Type

Pull #887

github

Committed by

web-flow

Commit Message

Merge f8fd1eea8 into 3e362a500

Pull Request Pull Request #887: feat: Viem migration

Run Details

223 of 356 branches covered (62.64%)

Branch coverage included in aggregate %.

53 of 56 new or added lines in 8 files covered. (94.64%)

18 existing lines in 5 files now uncovered.

768 of 918 relevant lines covered (83.66%)

3.21 hits per line

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

95.77

/packages/onramp-kit/src/packs/monerium/SafeMoneriumClient.ts

import { hashMessage, getBytes } from 'ethers'
import {
  getChain as getMoneriumChain,
  getNetwork as getMoneriumNetwork,
  Chain,
  IBAN,
  MoneriumClient,
  Networks,
  NewOrder,
  placeOrderMessage,
  ClassOptions
} from '@monerium/sdk'
import Safe, { getSignMessageLibContract, SafeProvider } from '@safe-global/protocol-kit'
import SafeApiKit from '@safe-global/api-kit'
import {
  decodeSignatureData,
  getErrorMessage,
  parseIsValidSignatureErrorResponse
} from '@safe-global/onramp-kit/lib/errors'
import { OperationType, SafeMultisigTransactionResponse } from '@safe-global/safe-core-sdk-types'

import {
  EIP_1271_BYTES_INTERFACE,
  EIP_1271_INTERFACE,
  MAGIC_VALUE,
  MAGIC_VALUE_BYTES
} from './signatures'
import { SafeMoneriumOrder } from './types'

export class SafeMoneriumClient extends MoneriumClient {
  #protocolKit: Safe
  #safeProvider: SafeProvider

  /**
   * Constructor where the Monerium environment and the Protocol kit instance are set
   * @param moneriumOptions The Monerium options object
   * @param protocolKit The Protocol kit instance
   */
  constructor(moneriumOptions: ClassOptions, protocolKit: Safe) {
    super(moneriumOptions)

    this.#protocolKit = protocolKit
    this.#safeProvider = protocolKit.getSafeProvider()
  }

  /**
   * We get the Safe address using the Protocol kit instance
   * @returns The Safe address
   */
  async getSafeAddress(): Promise<string> {
    return await this.#protocolKit.getAddress()
  }

  /**
   * Allow to make transactions using the Monerium SDK
   * @param order The order to be placed
   */
  async send(order: SafeMoneriumOrder): Promise<SafeMultisigTransactionResponse> {
    const safeAddress = await this.getSafeAddress()
    const newOrder = await this.#createOrder(safeAddress, order)

    try {
      // Place the order to Monerium and Safe systems for being linked between each other and confirmed
      await this.placeOrder(newOrder)

      const safeTransaction = await this.signMessage(safeAddress, newOrder.message)

      return safeTransaction
    } catch (error) {
      throw new Error(getErrorMessage(error))
    }
  }

  /**
   * Check if the message is signed in the smart contract
   * @param safeAddress The Safe address
   * @param message The message to be signed
   * @returns A boolean indicating if the message is signed
   */
  async isMessageSigned(safeAddress: string, message: string): Promise<boolean> {
    const messageHash = hashMessage(message)
    const messageHashSigned = await this.#isValidSignature(safeAddress, messageHash)
    return messageHashSigned
  }

  /**
   * Check if the message is pending (multi owner or not executed) using the Transaction Service
   * @param safeAddress The Safe address
   * @param message The message to be signed
   * @returns A boolean indicating if the message is signed
   */
  async isSignMessagePending(safeAddress: string, message: string): Promise<boolean> {
    const chainId = await this.#protocolKit.getChainId()

    const apiKit = new SafeApiKit({ chainId })

    const pendingTransactions = await apiKit.getPendingTransactions(safeAddress)

    return pendingTransactions.results.some((tx: SafeMultisigTransactionResponse) => {
      return (
        // @ts-expect-error - dataDecoded should have the method property
        tx?.dataDecoded?.method === 'signMessage' &&
        // @ts-expect-error - dataDecoded should have the parameters array
        tx?.dataDecoded?.parameters[0]?.value === hashMessage(message)
      )
    })
  }

  /**
   * Sign a message using the Safe SDK
   * @param safeAddress The Safe address
   * @param message The message to be signed
   */
  async signMessage(
    safeAddress: string,
    message: string
  ): Promise<SafeMultisigTransactionResponse> {
    try {
      const safeVersion = await this.#protocolKit.getContractVersion()

      const signMessageContract = await getSignMessageLibContract({
        safeProvider: this.#safeProvider,
        safeVersion
      })

      const txData = signMessageContract.encode('signMessage', [hashMessage(message)])

      const safeTransactionData = {
        to: await signMessageContract.getAddress(),
        value: '0',
        data: txData,
        operation: OperationType.DelegateCall
      }
      const safeTransaction = await this.#protocolKit.createTransaction({
        transactions: [safeTransactionData]
      })

      const safeTxHash = await this.#protocolKit.getTransactionHash(safeTransaction)

      const senderSignature = await this.#protocolKit.signHash(safeTxHash)

      const chainId = await this.#protocolKit.getChainId()

      const apiKit = new SafeApiKit({ chainId })

      await apiKit.proposeTransaction({
        safeAddress,
        safeTransactionData: safeTransaction.data,
        safeTxHash,
        senderAddress: (await this.#safeProvider.getSignerAddress()) || '',
        senderSignature: senderSignature.data
      })

      const transaction = await apiKit.getTransaction(safeTxHash)

      return transaction
    } catch (error) {
      throw new Error(getErrorMessage(error))
    }
  }

  /**
   * Get the current chain id
   * @returns The Chain Id
   */
  async getChainId(): Promise<number> {
    return Number(await this.#protocolKit.getChainId())
  }

  /**
   * Get the corresponding Monerium SDK Chain from the current chain id
   * @returns The Chain
   */
  async getChain(): Promise<Chain> {
    const chainId = await this.#protocolKit.getChainId()

    return getMoneriumChain(Number(chainId))
  }

  /**
   * Get the corresponding Monerium SDK Network from the current chain id
   * @returns The Network
   */
  async getNetwork(): Promise<Networks> {
    const chainId = await this.#protocolKit.getChainId()

    return getMoneriumNetwork(Number(chainId))
  }

  /**
   * Check if the message signature is valid using the fallback handler Smart Contract
   * @param safeAddress The Safe address
   * @param messageHash The message hash
   * @returns A boolean indicating if the message is signed
   */
  async #isValidSignature(safeAddress: string, messageHash: string): Promise<boolean> {
    try {
      const eip1271data = EIP_1271_INTERFACE.encodeFunctionData('isValidSignature', [
        messageHash,
        '0x'
      ])
      const msgBytes = getBytes(messageHash)

      const eip1271BytesData = EIP_1271_BYTES_INTERFACE.encodeFunctionData('isValidSignature', [
        msgBytes,
        '0x'
      ])

      const checks = [
        this.#safeProvider.call({
          from: safeAddress,
          to: safeAddress,
          data: eip1271data
        }),
        this.#safeProvider.call({
          from: safeAddress,
          to: safeAddress,
          data: eip1271BytesData
        })
      ]

      const responses = await Promise.allSettled(checks)

      return responses.reduce((prev, response) => {
        if (response.status === 'fulfilled') {
          return (
            prev ||
            decodeSignatureData(response.value) === MAGIC_VALUE ||
            decodeSignatureData(response.value) === MAGIC_VALUE_BYTES
          )
        }

        return (
          prev ||
          parseIsValidSignatureErrorResponse(response.reason) === MAGIC_VALUE ||
          parseIsValidSignatureErrorResponse(response.reason) === MAGIC_VALUE_BYTES
        )
      }, false)
    } catch (error) {
      throw new Error(getErrorMessage(error))
    }
  }

  /**
   * Create a valid order for the Monerium SDK
   * @param order The order to be created
   * @returns The Monerium type order
   */
  async #createOrder(safeAddress: string, order: SafeMoneriumOrder): Promise<NewOrder> {
    return {
      amount: order.amount,
      signature: '0x',
      address: safeAddress,
      // currency: order.currency,
      counterpart: order.counterpart,
      memo: order.memo,
      message: placeOrderMessage(order.amount, (order.counterpart.identifier as IBAN).iban),
      chainId: await this.getChainId(),
      supportingDocumentId: ''
    }
  }
}

1	import { hashMessage, getBytes } from 'ethers'	3✔
2	import {	3✔
3	getChain as getMoneriumChain,
4	getNetwork as getMoneriumNetwork,
5	Chain,
6	IBAN,
7	MoneriumClient,
8	Networks,
9	NewOrder,
10	placeOrderMessage,
11	ClassOptions
12	} from '@monerium/sdk'
13	import Safe, { getSignMessageLibContract, SafeProvider } from '@safe-global/protocol-kit'	3✔
14	import SafeApiKit from '@safe-global/api-kit'	3✔
15	import {	3✔
16	decodeSignatureData,
17	getErrorMessage,
18	parseIsValidSignatureErrorResponse
19	} from '@safe-global/onramp-kit/lib/errors'
20	import { OperationType, SafeMultisigTransactionResponse } from '@safe-global/safe-core-sdk-types'	3✔
21
22	import {	3✔
23	EIP_1271_BYTES_INTERFACE,
24	EIP_1271_INTERFACE,
25	MAGIC_VALUE,
26	MAGIC_VALUE_BYTES
27	} from './signatures'
28	import { SafeMoneriumOrder } from './types'
29
30	export class SafeMoneriumClient extends MoneriumClient {	3✔
31	#protocolKit: Safe	12✔
32	#safeProvider: SafeProvider	12✔
33
34	/**
35	* Constructor where the Monerium environment and the Protocol kit instance are set
36	* @param moneriumOptions The Monerium options object
37	* @param protocolKit The Protocol kit instance
38	*/
39	constructor(moneriumOptions: ClassOptions, protocolKit: Safe) {
40	super(moneriumOptions)	12✔
41
42	this.#protocolKit = protocolKit	12✔
43	this.#safeProvider = protocolKit.getSafeProvider()	12✔
44	}
45
46	/**
47	* We get the Safe address using the Protocol kit instance
48	* @returns The Safe address
49	*/
50	async getSafeAddress(): Promise<string> {
51	return await this.#protocolKit.getAddress()	3✔
52	}
53
54	/**
55	* Allow to make transactions using the Monerium SDK
56	* @param order The order to be placed
57	*/
58	async send(order: SafeMoneriumOrder): Promise<SafeMultisigTransactionResponse> {
59	const safeAddress = await this.getSafeAddress()	2✔
60	const newOrder = await this.#createOrder(safeAddress, order)	2✔
61
62	try {	2✔
63	// Place the order to Monerium and Safe systems for being linked between each other and confirmed
64	await this.placeOrder(newOrder)	2✔
65
66	const safeTransaction = await this.signMessage(safeAddress, newOrder.message)	2✔
67
68	return safeTransaction	1✔
69	} catch (error) {
70	throw new Error(getErrorMessage(error))	1✔
71	}
72	}
73
74	/**
75	* Check if the message is signed in the smart contract
76	* @param safeAddress The Safe address
77	* @param message The message to be signed
78	* @returns A boolean indicating if the message is signed
79	*/
80	async isMessageSigned(safeAddress: string, message: string): Promise<boolean> {
81	const messageHash = hashMessage(message)	4✔
82	const messageHashSigned = await this.#isValidSignature(safeAddress, messageHash)	4✔
83	return messageHashSigned	4✔
84	}
85
86	/**
87	* Check if the message is pending (multi owner or not executed) using the Transaction Service
88	* @param safeAddress The Safe address
89	* @param message The message to be signed
90	* @returns A boolean indicating if the message is signed
91	*/
92	async isSignMessagePending(safeAddress: string, message: string): Promise<boolean> {
93	const chainId = await this.#protocolKit.getChainId()	2✔
94
95	const apiKit = new SafeApiKit({ chainId })	2✔
96
97	const pendingTransactions = await apiKit.getPendingTransactions(safeAddress)	2✔
98
99	return pendingTransactions.results.some((tx: SafeMultisigTransactionResponse) => {	2✔
100	return (	1✔
101	// @ts-expect-error - dataDecoded should have the method property
102	tx?.dataDecoded?.method === 'signMessage' &&	2✔
103	// @ts-expect-error - dataDecoded should have the parameters array
104	tx?.dataDecoded?.parameters[0]?.value === hashMessage(message)
105	)
106	})
107	}
108
109	/**
110	* Sign a message using the Safe SDK
111	* @param safeAddress The Safe address
112	* @param message The message to be signed
113	*/
114	async signMessage(
115	safeAddress: string,
116	message: string
117	): Promise<SafeMultisigTransactionResponse> {
118	try {	1✔
119	const safeVersion = await this.#protocolKit.getContractVersion()	1✔
120
121	const signMessageContract = await getSignMessageLibContract({	1✔
122	safeProvider: this.#safeProvider,
123	safeVersion
124	})
125
126	const txData = signMessageContract.encode('signMessage', [hashMessage(message)])	1✔
127
128	const safeTransactionData = {	1✔
129	to: await signMessageContract.getAddress(),
130	value: '0',
131	data: txData,
132	operation: OperationType.DelegateCall
133	}
134	const safeTransaction = await this.#protocolKit.createTransaction({	1✔
135	transactions: [safeTransactionData]
136	})
137
138	const safeTxHash = await this.#protocolKit.getTransactionHash(safeTransaction)	1✔
139
140	const senderSignature = await this.#protocolKit.signHash(safeTxHash)	1✔
141
142	const chainId = await this.#protocolKit.getChainId()	1✔
143
144	const apiKit = new SafeApiKit({ chainId })	1✔
145
146	await apiKit.proposeTransaction({	1✔
147	safeAddress,
148	safeTransactionData: safeTransaction.data,
149	safeTxHash,
150	senderAddress: (await this.#safeProvider.getSignerAddress()) \|\| '',	1!
151	senderSignature: senderSignature.data
152	})
153
154	const transaction = await apiKit.getTransaction(safeTxHash)	1✔
155
156	return transaction	1✔
157	} catch (error) {
UNCOV 158	throw new Error(getErrorMessage(error))	×
159	}
160	}
161
162	/**
163	* Get the current chain id
164	* @returns The Chain Id
165	*/
166	async getChainId(): Promise<number> {
167	return Number(await this.#protocolKit.getChainId())	2✔
168	}
169
170	/**
171	* Get the corresponding Monerium SDK Chain from the current chain id
172	* @returns The Chain
173	*/
174	async getChain(): Promise<Chain> {
175	const chainId = await this.#protocolKit.getChainId()	7✔
176
177	return getMoneriumChain(Number(chainId))	7✔
178	}
179
180	/**
181	* Get the corresponding Monerium SDK Network from the current chain id
182	* @returns The Network
183	*/
184	async getNetwork(): Promise<Networks> {
185	const chainId = await this.#protocolKit.getChainId()	7✔
186
187	return getMoneriumNetwork(Number(chainId))	7✔
188	}
189
190	/**
191	* Check if the message signature is valid using the fallback handler Smart Contract
192	* @param safeAddress The Safe address
193	* @param messageHash The message hash
194	* @returns A boolean indicating if the message is signed
195	*/
196	async #isValidSignature(safeAddress: string, messageHash: string): Promise<boolean> {
197	try {	4✔
198	const eip1271data = EIP_1271_INTERFACE.encodeFunctionData('isValidSignature', [	4✔
199	messageHash,
200	'0x'
201	])
202	const msgBytes = getBytes(messageHash)	4✔
203
204	const eip1271BytesData = EIP_1271_BYTES_INTERFACE.encodeFunctionData('isValidSignature', [	4✔
205	msgBytes,
206	'0x'
207	])
208
209	const checks = [	4✔
210	this.#safeProvider.call({
211	from: safeAddress,
212	to: safeAddress,
213	data: eip1271data
214	}),
215	this.#safeProvider.call({
216	from: safeAddress,
217	to: safeAddress,
218	data: eip1271BytesData
219	})
220	]
221
222	const responses = await Promise.allSettled(checks)	4✔
223
224	return responses.reduce((prev, response) => {	4✔
225	if (response.status === 'fulfilled') {	8✔
226	return (	4✔
227	prev \|\|	9✔
228	decodeSignatureData(response.value) === MAGIC_VALUE \|\|
229	decodeSignatureData(response.value) === MAGIC_VALUE_BYTES
230	)
231	}
232
233	return (	4✔
234	prev \|\|	9✔
235	parseIsValidSignatureErrorResponse(response.reason) === MAGIC_VALUE \|\|
236	parseIsValidSignatureErrorResponse(response.reason) === MAGIC_VALUE_BYTES
237	)
238	}, false)
239	} catch (error) {
UNCOV 240	throw new Error(getErrorMessage(error))	×
241	}
242	}
243
244	/**
245	* Create a valid order for the Monerium SDK
246	* @param order The order to be created
247	* @returns The Monerium type order
248	*/
249	async #createOrder(safeAddress: string, order: SafeMoneriumOrder): Promise<NewOrder> {
250	return {	2✔
251	amount: order.amount,
252	signature: '0x',
253	address: safeAddress,
254	// currency: order.currency,
255	counterpart: order.counterpart,
256	memo: order.memo,
257	message: placeOrderMessage(order.amount, (order.counterpart.identifier as IBAN).iban),
258	chainId: await this.getChainId(),
259	supportingDocumentId: ''
260	}
261	}
262	}

safe-global / safe-core-sdk / 9697300982

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