9856259104

Committed 09 Jul 2024 11:33AM UTC coverage: 74.541% (+0.08%) from 74.465%

Build # 9856259104

Build Type

Pull #887

github

Committed by

web-flow

Commit Message

Merge 512970909 into 8c85ff39e

Pull Request Pull Request #887: feat: Viem migration

Run Details

225 of 374 branches covered (60.16%)

Branch coverage included in aggregate %.

71 of 75 new or added lines in 13 files covered. (94.67%)

12 existing lines in 4 files now uncovered.

791 of 989 relevant lines covered (79.98%)

3.03 hits per line

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

95.71

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

import { Hash, encodeFunctionData, hashMessage } from 'viem'
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_ABI, EIP_1271_BYTES_ABI, 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, eip1271BytesData] = [EIP_1271_ABI, EIP_1271_BYTES_ABI].map((abi) =>
        encodeFunctionData({
          abi,
          functionName: 'isValidSignature',
          args: [messageHash as Hash, '0x']
        })
      )

      const responses = await Promise.allSettled(
        [eip1271data, eip1271BytesData].map((data) =>
          this.#safeProvider.call({
            from: safeAddress,
            to: safeAddress,
            data
          })
        )
      )

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

safe-global / safe-core-sdk / 9856259104

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