feat(api-kit): 4337 API functions

packages/api-kit/.env.example

@@ -1,2 +1,3 @@
 MNEMONIC=
-PK=
+PK=
+PIMLICO_API_KEY=

packages/api-kit/src/SafeApiKit.ts

@@ -1,10 +1,12 @@
 import {
   AddMessageProps,
   AddSafeDelegateProps,
+  AddSafeOperationProps,
   AllTransactionsListResponse,
   AllTransactionsOptions,
   DeleteSafeDelegateProps,
   GetSafeDelegateProps,
+  GetSafeOperationListResponse,
   SafeSingletonResponse,
   GetSafeMessageListProps,
   ModulesResponse,
@@ -20,6 +22,7 @@
   SafeMultisigTransactionEstimate,
   SafeMultisigTransactionEstimateResponse,
   SafeMultisigTransactionListResponse,
+  SafeOperationResponse,
   SafeServiceInfoResponse,
   SignatureResponse,
   TokenInfoListResponse,
@@ -34,6 +37,7 @@
   SafeMultisigTransactionResponse
 } from '@safe-global/safe-core-sdk-types'
 import { TRANSACTION_SERVICE_URLS } from './utils/config'
+import { isEmptyHexData } from './utils'
 
 export interface SafeApiKitConfig {
   /** chainId - The chainId */
@@ -109,7 +113,7 @@
    * @throws "Not Found"
    * @throws "Ensure this field has at least 1 hexadecimal chars (not counting 0x)."
    */
   async decodeData(data: string): Promise<any> {
     if (data === '') {
       throw new Error('Invalid data')
     }
@@ -319,7 +323,7 @@
     const totp = Math.floor(Date.now() / 1000 / 3600)
     const data = delegate + totp
     const signature = await signer.signMessage(data)
     const body: any = {
       safe: safeAddress ? this.#getEip3770Address(safeAddress).address : null,
       delegate,
       delegator,
@@ -715,6 +719,110 @@
       }
     })
   }
+
+  /**
+   * Get the SafeOperations that were sent from a particular address.
+   * @param safeAddress - The Safe address to retrieve SafeOperations for
+   * @throws "Safe address must not be empty"
+   * @throws "Invalid Ethereum address {safeAddress}"
+   * @returns The SafeOperations sent from the given Safe's address
+   */
+  async getSafeOperationsByAddress(safeAddress: string): Promise<GetSafeOperationListResponse> {
+    if (!safeAddress) {
+      throw new Error('Safe address must not be empty')
+    }
+    const { address } = this.#getEip3770Address(safeAddress)
+
+    return sendRequest({
+      url: `${this.#txServiceBaseUrl}/v1/safes/${address}/safe-operations/`,
+      method: HttpMethod.Get
+    })
+  }
+
+  /**
+   * Get a SafeOperation by its hash.
+   * @param safeOperationHash The SafeOperation hash
+   * @throws "SafeOperation hash must not be empty"
+   * @throws "Not found."
+   * @returns The SafeOperation
+   */
+  async getSafeOperation(safeOperationHash: string): Promise<SafeOperationResponse> {
+    if (!safeOperationHash) {
+      throw new Error('SafeOperation hash must not be empty')
+    }
+
+    return sendRequest({
+      url: `${this.#txServiceBaseUrl}/v1/safe-operations/${safeOperationHash}/`,
+      method: HttpMethod.Get
+    })
+  }
+
+  /**
+   * Create a new 4337 SafeOperation for a Safe.
+   * @param addSafeOperationProps - The configuration of the SafeOperation
+   * @throws "Safe address must not be empty"
+   * @throws "Invalid Safe address {safeAddress}"
+   * @throws "Module address must not be empty"
+   * @throws "Invalid module address {moduleAddress}"
+   * @throws "SafeOperation is not signed by the given signer {signerAddress}"
+   */
+  async addSafeOperation({
+    moduleAddress: moduleAddressProp,
+    safeAddress: safeAddressProp,
+    safeOperation,
+    signer
+  }: AddSafeOperationProps): Promise<void> {
+    let safeAddress: string, moduleAddress: string
+
+    if (!safeAddressProp) {
+      throw new Error('Safe address must not be empty')
+    }
+    try {
+      safeAddress = this.#getEip3770Address(safeAddressProp).address
+    } catch (err) {
+      throw new Error(`Invalid Safe address ${safeAddressProp}`)
+    }
+
+    if (!moduleAddressProp) {
+      throw new Error('Module address must not be empty')
+    }
+
+    try {
+      moduleAddress = this.#getEip3770Address(moduleAddressProp).address
+    } catch (err) {
+      throw new Error(`Invalid module address ${moduleAddressProp}`)
+    }
+
+    const signerAddress = await signer.getAddress()
+    const signature = safeOperation.getSignature(signerAddress)
+
+    if (!signature) {
+      throw new Error(`SafeOperation is not signed by the given signer ${signerAddress}`)
+    }
+
+    const { data } = safeOperation
+
+    return sendRequest({
+      url: `${this.#txServiceBaseUrl}/v1/safes/${safeAddress}/safe-operations/`,
+      method: HttpMethod.Post,
+      body: {
+        nonce: Number(data.nonce),
+        initCode: isEmptyHexData(data.initCode) ? null : data.initCode,
+        callData: data.callData,
+        callDataGasLimit: data.callGasLimit.toString(),
+        verificationGasLimit: data.verificationGasLimit.toString(),
+        preVerificationGas: data.preVerificationGas.toString(),
+        maxFeePerGas: data.maxFeePerGas.toString(),
+        maxPriorityFeePerGas: data.maxPriorityFeePerGas.toString(),
+        paymasterAndData: isEmptyHexData(data.paymasterAndData) ? null : data.paymasterAndData,
+        entryPoint: data.entryPoint,
+        validAfter: !data.validAfter ? null : data.validAfter,
+        validUntil: !data.validUntil ? null : data.validUntil,
+        signature: signature.data,
+        moduleAddress
+      }
+    })
+  }
 }
 
 export default SafeApiKit

packages/api-kit/src/types/safeTransactionServiceTypes.ts

@@ -3,6 +3,7 @@ import {
   SafeMultisigTransactionResponse,
   SafeTransactionData
 } from '@safe-global/safe-core-sdk-types'
+import SafeOperation from '@safe-global/relay-kit/src/packs/safe-4337/SafeOperation'
 
 export type SafeServiceInfoResponse = {
   readonly name: string
@@ -287,3 +288,55 @@ export type EIP712TypedData = {
   types: TypedDataField
   message: Record<string, unknown>
 }
+
+export type SafeOperationConfirmation = {
+  readonly created: string
+  readonly modified: string
+  readonly owner: string
+  readonly signature: string
+  readonly signatureType: string
+}
+
+export type SafeOperationResponse = {
+  readonly created: string
+  readonly modified: string
+  readonly ethereumTxHash: string
+  readonly sender: string
+  readonly userOperationHash: string
+  readonly safeOperationHash: string
+  readonly nonce: number
+  readonly initCode: null | string
+  readonly callData: null | string
+  readonly callDataGasLimit: number
+  readonly verificationGasLimit: number
+  readonly preVerificationGas: number
+  readonly maxFeePerGas: number
+  readonly maxPriorityFeePerGas: number
+  readonly paymaster: null | string
+  readonly paymasterData: null | string
+  readonly signature: string
+  readonly entryPoint: string
+  readonly validAfter: string
+  readonly validUntil: string
+  readonly moduleAddress: string
+  readonly confirmations?: Array<SafeOperationConfirmation>
+  readonly preparedSignature?: string
+}
+
+export type GetSafeOperationListResponse = {
+  readonly count: number
+  readonly next?: string
+  readonly previous?: string
+  readonly results: Array<SafeOperationResponse>
+}
+
+export type AddSafeOperationProps = {
+  /** Address of the Safe4337Module contract */
+  moduleAddress: string
+  /** Address of the Safe to add a SafeOperation for */
+  safeAddress: string
+  /** Signed SafeOperation object to add */
+  safeOperation: SafeOperation
+  /** Signer instance */
+  signer: Signer
+}

packages/api-kit/src/utils/constants.ts

@@ -0,0 +1 @@
+export const EMPTY_DATA = '0x'

packages/api-kit/src/utils/index.ts

@@ -0,0 +1,3 @@
+import { EMPTY_DATA } from './constants'
+
+export const isEmptyHexData = (input: string) => !input || input === EMPTY_DATA

packages/api-kit/tests/e2e/addSafeOperation.test.ts

@@ -0,0 +1,171 @@
+import chai from 'chai'
+import chaiAsPromised from 'chai-as-promised'
+import dotenv from 'dotenv'
+import { Wallet, ethers } from 'ethers'
+import { EthAdapter } from '@safe-global/safe-core-sdk-types'
+import SafeApiKit from '@safe-global/api-kit'
+import { Safe4337Pack } from '@safe-global/relay-kit'
+import { generateTransferCallData } from '@safe-global/relay-kit/src/packs/safe-4337/testing-utils/helpers'
+import { getSafe4337ModuleDeployment } from '@safe-global/safe-modules-deployments'
+import { EthersAdapter } from 'packages/protocol-kit'
+import { getServiceClient } from '../utils/setupServiceClient'
+import config from '../utils/config'
+
+dotenv.config()
+
+const { PIMLICO_API_KEY } = process.env
+
+chai.use(chaiAsPromised)
+
+const SIGNER_PK = '0x83a415ca62e11f5fa5567e98450d0f82ae19ff36ef876c10a8d448c788a53676'
+const SAFE_ADDRESS = '0x60C4Ab82D06Fd7dFE9517e17736C2Dcc77443EF0' // 1/1 Safe (v1.4.1) with signer above as owner + 4337 module enabled
+const PAYMASTER_TOKEN_ADDRESS = '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238'
+const PAYMASTER_ADDRESS = '0x0000000000325602a77416A16136FDafd04b299f'
+const BUNDLER_URL = `https://api.pimlico.io/v1/sepolia/rpc?apikey=${PIMLICO_API_KEY}`
+const TX_SERVICE_URL = 'https://safe-transaction-sepolia.staging.5afe.dev/api'
+
+let safeApiKit: SafeApiKit
+let ethAdapter: EthAdapter
+let safe4337Pack: Safe4337Pack
+let signer: Wallet
+let moduleAddress: string
+
+describe('addSafeOperation', () => {
+  const transferUSDC = {
+    to: PAYMASTER_TOKEN_ADDRESS,
+    data: generateTransferCallData(SAFE_ADDRESS, 100_000n),
+    value: '0',
+    operation: 0
+  }
+
+  before(async () => {
+    ;({ safeApiKit, ethAdapter, signer } = await getServiceClient(SIGNER_PK, TX_SERVICE_URL))
+
+    const ethersAdapter = new EthersAdapter({
+      ethers,
+      signerOrProvider: signer
+    })
+
+    safe4337Pack = await Safe4337Pack.init({
+      options: { safeAddress: SAFE_ADDRESS },
+      ethersAdapter,
+      rpcUrl: config.JSON_RPC,
+      bundlerUrl: BUNDLER_URL,
+      paymasterOptions: {
+        paymasterTokenAddress: PAYMASTER_TOKEN_ADDRESS,
+        paymasterAddress: PAYMASTER_ADDRESS
+      }
+    })
+
+    const chainId = (await ethAdapter.getChainId()).toString()
+
+    moduleAddress = getSafe4337ModuleDeployment({
+      released: true,
+      version: '0.2.0',
+      network: chainId
+    })?.networkAddresses[chainId] as string
+  })
+
+  describe('should fail', () => {
+    it('if safeAddress is empty', async () => {
+      const safeOperation = await safe4337Pack.createTransaction({ transactions: [transferUSDC] })
+      const signedSafeOperation = await safe4337Pack.signSafeOperation(safeOperation)
+
+      await chai
+        .expect(
+          safeApiKit.addSafeOperation({
+            moduleAddress,
+            safeAddress: '',
+            safeOperation: signedSafeOperation,
+            signer
+          })
+        )
+        .to.be.rejectedWith('Safe address must not be empty')
+    })
+
+    it('if safeAddress is invalid', async () => {
+      const safeOperation = await safe4337Pack.createTransaction({ transactions: [transferUSDC] })
+      const signedSafeOperation = await safe4337Pack.signSafeOperation(safeOperation)
+
+      await chai
+        .expect(
+          safeApiKit.addSafeOperation({
+            moduleAddress,
+            safeAddress: '0x123',
+            safeOperation: signedSafeOperation,
+            signer
+          })
+        )
+        .to.be.rejectedWith('Invalid Safe address 0x123')
+    })
+
+    it('if moduleAddress is empty', async () => {
+      const safeOperation = await safe4337Pack.createTransaction({ transactions: [transferUSDC] })
+      const signedSafeOperation = await safe4337Pack.signSafeOperation(safeOperation)
+
+      await chai
+        .expect(
+          safeApiKit.addSafeOperation({
+            moduleAddress: '',
+            safeAddress: SAFE_ADDRESS,
+            safeOperation: signedSafeOperation,
+            signer
+          })
+        )
+        .to.be.rejectedWith('Module address must not be empty')
+    })
+
+    it('if moduleAddress is invalid', async () => {
+      const safeOperation = await safe4337Pack.createTransaction({ transactions: [transferUSDC] })
+      const signedSafeOperation = await safe4337Pack.signSafeOperation(safeOperation)
+
+      await chai
+        .expect(
+          safeApiKit.addSafeOperation({
+            moduleAddress: '0x234',
+            safeAddress: SAFE_ADDRESS,
+            safeOperation: signedSafeOperation,
+            signer
+          })
+        )
+        .to.be.rejectedWith('Invalid module address 0x234')
+    })
+
+    it('if the SafeOperation is not signed', async () => {
+      const safeOperation = await safe4337Pack.createTransaction({ transactions: [transferUSDC] })
+
+      await chai
+        .expect(
+          safeApiKit.addSafeOperation({
+            moduleAddress,
+            safeAddress: SAFE_ADDRESS,
+            safeOperation,
+            signer
+          })
+        )
+        .to.be.rejectedWith(
+          'SafeOperation is not signed by the given signer 0x56e2C102c664De6DfD7315d12c0178b61D16F171'
+        )
+    })
+  })
+
+  it('should add a new SafeOperation', async () => {
+    const safeOperation = await safe4337Pack.createTransaction({ transactions: [transferUSDC] })
+    const signedSafeOperation = await safe4337Pack.signSafeOperation(safeOperation)
+
+    const safeOperationsBefore = await safeApiKit.getSafeOperationsByAddress(SAFE_ADDRESS)
+    const initialNumSafeOperations = safeOperationsBefore.results.length
+
+    await chai.expect(
+      safeApiKit.addSafeOperation({
+        moduleAddress,
+        safeAddress: SAFE_ADDRESS,
+        safeOperation: signedSafeOperation,
+        signer
+      })
+    ).to.be.fulfilled
+
+    const safeOperationsAfter = await safeApiKit.getSafeOperationsByAddress(SAFE_ADDRESS)
+    chai.expect(safeOperationsAfter.results.length).to.equal(initialNumSafeOperations + 1)
+  })
+})