feat(protocol-kit): Add deployment functionality to Safe class + Viem

guides/integrating-the-safe-core-sdk.md

@@ -55,9 +55,7 @@ const apiKit = new SafeApiKit({
 ### Initialize the Protocol Kit
 
 ```js
-import Safe, { SafeFactory } from '@safe-global/protocol-kit'
-
-const safeFactory = await SafeFactory.init({ provider, signer })
+import Safe from '@safe-global/protocol-kit'
 
 const protocolKit = await Safe.init({ provider, signer, safeAddress })
 ```
@@ -67,7 +65,6 @@ There are two versions of the Safe contracts: [Safe.sol](https://github.com/safe
 By default `Safe.sol` will be only used on Ethereum Mainnet. For the rest of the networks where the Safe contracts are already deployed, the `SafeL2.sol` contract will be used unless you add the property `isL1SafeSingleton` to force the use of the `Safe.sol` contract.
 
 ```js
-const safeFactory = await SafeFactory.init({ provider, signer, isL1SafeSingleton: true })
 
 const protocolKit = await Safe.init({ provider, signer, safeAddress, isL1SafeSingleton: true })
 ```
@@ -102,21 +99,12 @@ const contractNetworks: ContractNetworksConfig = {
   }
 }
 
-const safeFactory = await SafeFactory.init({ provider, signer, contractNetworks })
-
 const protocolKit = await Safe.init({ provider, signer, safeAddress, contractNetworks })
 ```
 
-The `SafeFactory` constructor also accepts the property `safeVersion` to specify the Safe contract version that will be deployed. This string can take the values `1.0.0`, `1.1.1`, `1.2.0`, `1.3.0` or `1.4.1`. If not specified, the `DEFAULT_SAFE_VERSION` value will be used.
-
-```js
-const safeVersion = 'X.Y.Z'
-const safeFactory = await SafeFactory.init({ provider, signer, safeVersion })
-```
-
 ## <a name="deploy-safe">3. Deploy a new Safe</a>
 
-The Protocol Kit library allows the deployment of new Safes using the `safeFactory` instance we just created.
+The Protocol Kit library allows the deployment of new Safes using the `deploy` method.
 
 Here, for example, we can create a new Safe account with 3 owners and 2 required signatures.
 
@@ -128,10 +116,13 @@ const safeAccountConfig: SafeAccountConfig = {
   threshold: 2,
   // ... (optional params)
 }
-const protocolKit = await safeFactory.deploySafe({ safeAccountConfig })
+
+const predictedSafe = await Safe.init({ provider, signer, predictSafe, contractNetworks })
+
+const protocolKit = await predictedSafe.deploy()
 ```
 
-Calling the method `deploySafe` will deploy the desired Safe and return a Protocol Kit initialized instance ready to be used. Check the [API Reference](https://github.com/safe-global/safe-core-sdk/tree/main/packages/protocol-kit#deploysafe) for more details on additional configuration parameters and callbacks.
+Calling the method `deploy` will deploy the desired Safe and return a Protocol Kit initialized instance ready to be used. Check the [API Reference](https://github.com/safe-global/safe-core-sdk/tree/main/packages/protocol-kit#deploysafe) for more details on additional configuration parameters and callbacks.
 
 ## <a name="create-transaction">4. Create a transaction</a>
 

packages/protocol-kit/src/Safe.ts

@@ -19,7 +19,10 @@ import {
   encodeSetupCallData,
   getChainSpecificDefaultSaltNonce,
   getPredictedSafeAddressInitCode,
-  predictSafeAddress
+  getSafeAddressFromDeploymentTx,
+  predictSafeAddress,
+  validateSafeAccountConfig,
+  validateSafeDeploymentConfig
 } from './contracts/utils'
 import { DEFAULT_SAFE_VERSION } from './contracts/config'
 import ContractManager from './managers/contractManager'
@@ -57,6 +60,7 @@ import {
   generateSignature,
   preimageSafeMessageHash,
   preimageSafeTransactionHash,
+  toTransactionRequest,
   adjustVInSignature
 } from './utils'
 import EthSafeTransaction from './utils/transactions/SafeTransaction'
@@ -79,7 +83,7 @@ import SafeMessage from './utils/messages/SafeMessage'
 import semverSatisfies from 'semver/functions/satisfies'
 import SafeProvider from './SafeProvider'
 import { asHash, asHex } from './utils/types'
-import { Hash, Hex } from 'viem'
+import { Hash, Hex, WalletClient, Transport, Chain, Account } from 'viem'
 import getPasskeyOwnerAddress from './utils/passkeys/getPasskeyOwnerAddress'
 import createPasskeyDeploymentTransaction from './utils/passkeys/createPasskeyDeploymentTransaction'
 
@@ -264,13 +268,6 @@ class Safe {
    */
   async getAddress(): Promise<string> {
     if (this.#predictedSafe) {
-      const safeVersion = await this.getContractVersion()
-      if (!hasSafeFeature(SAFE_FEATURES.ACCOUNT_ABSTRACTION, safeVersion)) {
-        throw new Error(
-          'Account Abstraction functionality is not available for Safes with version lower than v1.3.0'
-        )
-      }
-
       const chainId = await this.#safeProvider.getChainId()
       return predictSafeAddress({
         safeProvider: this.#safeProvider,
@@ -881,7 +878,7 @@ class Safe {
    */
   async getOwnersWhoApprovedTx(txHash: string): Promise<string[]> {
     if (!this.#contractManager.safeContract) {
-      throw new Error('Safe is not deployed')
+      return []
     }
 
     const owners = await this.getOwners()
@@ -912,6 +909,13 @@ class Safe {
     fallbackHandlerAddress: string,
     options?: SafeTransactionOptionalProps
   ): Promise<SafeTransaction> {
+    const safeVersion = await this.getContractVersion()
+    if (this.#predictedSafe && !hasSafeFeature(SAFE_FEATURES.ACCOUNT_ABSTRACTION, safeVersion)) {
+      throw new Error(
+        'Account Abstraction functionality is not available for Safes with version lower than v1.3.0'
+      )
+    }
+
     const safeTransactionData = {
       to: await this.getAddress(),
       value: '0',
@@ -937,6 +941,13 @@ class Safe {
   async createDisableFallbackHandlerTx(
     options?: SafeTransactionOptionalProps
   ): Promise<SafeTransaction> {
+    const safeVersion = await this.getContractVersion()
+    if (this.#predictedSafe && !hasSafeFeature(SAFE_FEATURES.ACCOUNT_ABSTRACTION, safeVersion)) {
+      throw new Error(
+        'Account Abstraction functionality is not available for Safes with version lower than v1.3.0'
+      )
+    }
+
     const safeTransactionData = {
       to: await this.getAddress(),
       value: '0',
@@ -1309,16 +1320,51 @@ class Safe {
       ? await this.toSafeTransactionType(safeTransaction)
       : safeTransaction
 
+    const signedSafeTransaction = await this.#addPreValidatedSignature(transaction)
+
+    await this.#isReadyToExecute(signedSafeTransaction)
+
+    const value = BigInt(signedSafeTransaction.data.value)
+    if (value !== 0n) {
+      const balance = await this.getBalance()
+      if (value > balance) {
+        throw new Error('Not enough Ether funds')
+      }
+    }
+
+    const signerAddress = await this.#safeProvider.getSignerAddress()
+
+    const txResponse = await this.#contractManager.safeContract.execTransaction(
+      signedSafeTransaction,
+      {
+        from: signerAddress,
+        ...options
+      }
+    )
+    return txResponse
+  }
+
+  /**
+   * Adds a PreValidatedSignature to the transaction if the threshold is not reached.
+   *
+   * @async
+   * @param {SafeTransaction} transaction - The transaction to add a signature to.
+   * @returns {Promise<SafeTransaction>} A promise that resolves to the signed transaction.
+   */
+  async #addPreValidatedSignature(transaction: SafeTransaction): Promise<SafeTransaction> {
     const signedSafeTransaction = await this.copyTransaction(transaction)
 
     const txHash = await this.getTransactionHash(signedSafeTransaction)
     const ownersWhoApprovedTx = await this.getOwnersWhoApprovedTx(txHash)
+
     for (const owner of ownersWhoApprovedTx) {
       signedSafeTransaction.addSignature(generatePreValidatedSignature(owner))
     }
+
     const owners = await this.getOwners()
     const threshold = await this.getThreshold()
     const signerAddress = await this.#safeProvider.getSignerAddress()
+
     if (
       threshold > signedSafeTransaction.signatures.size &&
       signerAddress &&
@@ -1327,31 +1373,122 @@ class Safe {
       signedSafeTransaction.addSignature(generatePreValidatedSignature(signerAddress))
     }
 
-    if (threshold > signedSafeTransaction.signatures.size) {
-      const signaturesMissing = threshold - signedSafeTransaction.signatures.size
+    return signedSafeTransaction
+  }
+
+  /**
+   * Checks if the transaction has enough signatures to be executed.
+   *
+   * @async
+   * @param {SafeTransaction} transaction - The Safe transaction to check.
+   * @throws Will throw an error if the required number of signatures is not met.
+   */
+  async #isReadyToExecute(transaction: SafeTransaction) {
+    const threshold = await this.getThreshold()
+
+    if (threshold > transaction.signatures.size) {
+      const signaturesMissing = threshold - transaction.signatures.size
       throw new Error(
         `There ${signaturesMissing > 1 ? 'are' : 'is'} ${signaturesMissing} signature${
           signaturesMissing > 1 ? 's' : ''
         } missing`
       )
     }
+  }
 
-    const value = BigInt(signedSafeTransaction.data.value)
-    if (value !== 0n) {
-      const balance = await this.getBalance()
-      if (value > balance) {
-        throw new Error('Not enough Ether funds')
-      }
+  /**
+   * Deploys a Safe and optionally executes a transaction in a batch
+   *
+   * @param safeTransaction - The Safe transaction to execute
+   * @param options - The Safe transaction execution options. Optional
+   * @throws "No signer provided"
+   * @throws "There are X signatures missing"
+   * @returns The new instance of the SDK with the Safe deployed
+   */
+  async deploy(
+    safeTransaction?: SafeTransaction | SafeMultisigTransactionResponse,
+    options: TransactionOptions = {}
+  ): Promise<Safe> {
+    const isSafeDeployed = await this.isSafeDeployed()
+
+    // if the safe is already deployed throws an error
+    if (isSafeDeployed) {
+      throw new Error('Safe already deployed')
     }
 
-    const txResponse = await this.#contractManager.safeContract.execTransaction(
-      signedSafeTransaction,
-      {
+    if (!this.#predictedSafe) {
+      throw new Error('Predict Safe should be present')
+    }
+
+    const signer = (await this.#safeProvider.getExternalSigner()) as WalletClient<
+      Transport,
+      Chain,
+      Account
+    >
+
+    if (!signer) {
+      throw new Error('signer should be present')
+    }
+
+    validateSafeAccountConfig(this.#predictedSafe.safeAccountConfig)
+    validateSafeDeploymentConfig(this.#predictedSafe?.safeDeploymentConfig || {})
+
+    const signerAddress = (await this.#safeProvider.getSignerAddress()) || '0x'
+
+    let txReceipt
+
+    if (safeTransaction) {
+      const transaction = isSafeMultisigTransactionResponse(safeTransaction)
+        ? await this.toSafeTransactionType(safeTransaction)
+        : safeTransaction
+
+      const signedSafeTransaction = await this.#addPreValidatedSignature(transaction)
+
+      await this.#isReadyToExecute(signedSafeTransaction)
+
+      // we add the Safe deployment to the batch
+      const deploymentBatch = await this.wrapSafeTransactionIntoDeploymentBatch(
+        signedSafeTransaction,
+        options
+      )
+
+      const tx = toTransactionRequest({
         from: signerAddress,
+        ...deploymentBatch,
         ...options
-      }
-    )
-    return txResponse
+      })
+
+      // await for the deployment
+      const hash = await signer.sendTransaction(tx)
+
+      txReceipt = await this.getSafeProvider()
+        .getExternalProvider()
+        .waitForTransactionReceipt({ hash })
+    } else {
+      // we create the deployment transaction
+      const safeDeploymentTransaction = await this.createSafeDeploymentTransaction(undefined, {
+        ...options,
+        from: signerAddress
+      })
+
+      const hash = await signer.sendTransaction(toTransactionRequest(safeDeploymentTransaction))
+
+      txReceipt = await this.getSafeProvider()
+        .getExternalProvider()
+        .waitForTransactionReceipt({ hash })
+    }
+
+    const safeVersion = await this.getContractVersion()
+    const safeAddress = getSafeAddressFromDeploymentTx(txReceipt!, safeVersion)
+
+    const isSafeProxyContractDeployed = await this.#safeProvider.isContractDeployed(safeAddress)
+
+    if (!isSafeProxyContractDeployed) {
+      throw new Error('SafeProxy contract is not deployed on the current network')
+    }
+
+    // return a new instance of the SDK with the safe deployed
+    return this.connect({ signer: this.#safeProvider.signer, safeAddress })
   }
 
   /**