@safe-global/protocol-kit 4.1.1 → 5.0.1

package/dist/src/Safe.d.ts

@@ -1,4 +1,5 @@
-import { SafeMultisigTransactionResponse, SafeSignature, SafeTransaction, SafeVersion, TransactionOptions, TransactionResult, MetaTransactionData, Transaction, EIP712TypedData } from '@safe-global/safe-core-sdk-types';
+import { SafeMultisigTransactionResponse, SafeSignature, SafeTransaction, SafeVersion, TransactionOptions, TransactionResult, MetaTransactionData, Transaction, EIP712TypedData } from '@safe-global/types-kit';
+import { ContractInfo } from './contracts/config';
 import ContractManager from './managers/contractManager';
 import { AddOwnerTxParams, AddPasskeyOwnerTxParams, ConnectSafeConfig, CreateTransactionProps, PredictedSafeProps, RemoveOwnerTxParams, SafeConfig, SigningMethodType, SwapOwnerTxParams, SafeModulesPaginated, RemovePasskeyOwnerTxParams } from './types';
 import { SafeTransactionOptionalProps } from './utils/transactions/types';
@@ -59,13 +60,13 @@ declare class Safe {
      *
      * @returns The address of the MultiSend contract
      */
-    getMultiSendAddress(): Promise<string>;
+    getMultiSendAddress(): string;
     /**
      * Returns the address of the MultiSendCallOnly contract.
      *
      * @returns The address of the MultiSendCallOnly contract
      */
-    getMultiSendCallOnlyAddress(): Promise<string>;
+    getMultiSendCallOnlyAddress(): string;
     /**
      * Checks if the current Safe is deployed.
      *
@@ -77,7 +78,7 @@ declare class Safe {
      *
      * @returns The Safe Singleton contract version
      */
-    getContractVersion(): Promise<SafeVersion>;
+    getContractVersion(): SafeVersion;
     /**
      * Returns the list of Safe owner accounts.
      *
@@ -392,26 +393,17 @@ declare class Safe {
      * @async
      * @param {SafeTransaction} safeTransaction - The Safe transaction to be wrapped into the deployment batch.
      * @param {TransactionOptions} [transactionOptions] - Optional. Options for the transaction, such as from, gas price, gas limit, etc.
-     * @param {string} [customSaltNonce] - Optional. a Custom salt nonce to be used for the deployment of the Safe. If not provided, a default value is used.
      * @returns {Promise<Transaction>} A promise that resolves to a Transaction object representing the prepared batch of transactions.
      * @throws Will throw an error if the safe is already deployed.
      *
      */
-    wrapSafeTransactionIntoDeploymentBatch(safeTransaction: SafeTransaction, transactionOptions?: TransactionOptions, customSaltNonce?: string): Promise<Transaction>;
+    wrapSafeTransactionIntoDeploymentBatch(safeTransaction: SafeTransaction, transactionOptions?: TransactionOptions): Promise<Transaction>;
     /**
-     * Creates a Safe deployment transaction.
-     *
-     * This function prepares a transaction for the deployment of a Safe.
-     * Both the saltNonce and options parameters are optional, and if not
-     * provided, default values will be used.
-     *
-     * @async
-     * @param {string} [customSaltNonce] - Optional. a Custom salt nonce to be used for the deployment of the Safe. If not provided, a default value is used.
-     * @param {TransactionOptions} [options] - Optional. Options for the transaction, such as gas price, gas limit, etc.
-     * @returns {Promise<Transaction>} A promise that resolves to a Transaction object representing the prepared Safe deployment transaction.
+     * Creates a transaction to deploy a Safe Account.
      *
+     * @returns {Promise<Transaction>} Returns a promise that resolves to an Ethereum transaction with the fields `to`, `value`, and `data`, which can be used to deploy the Safe Account.
      */
-    createSafeDeploymentTransaction(customSaltNonce?: string, transactionOptions?: TransactionOptions): Promise<Transaction>;
+    createSafeDeploymentTransaction(): Promise<Transaction>;
     /**
      * This function creates a batch of the provided Safe transactions using the MultiSend contract.
      * It groups the transactions together into a single transaction which can then be executed atomically.
@@ -444,5 +436,8 @@ declare class Safe {
      * @link https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol
      */
     isValidSignature: (messageHash: string, signature?: SafeSignature[] | string) => Promise<boolean>;
+    getContractInfo: ({ contractAddress }: {
+        contractAddress: string;
+    }) => ContractInfo | undefined;
 }
 export default Safe;

package/dist/src/Safe.js

@@ -13,9 +13,9 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Safe_instances, _Safe_predictedSafe, _Safe_safeProvider, _Safe_contractManager, _Safe_ownerManager, _Safe_moduleManager, _Safe_guardManager, _Safe_fallbackHandlerManager, _Safe_MAGIC_VALUE, _Safe_MAGIC_VALUE_BYTES, _Safe_initializeProtocolKit, _Safe_getFallbackHandlerContract;
+var _Safe_instances, _Safe_predictedSafe, _Safe_safeProvider, _Safe_contractManager, _Safe_ownerManager, _Safe_moduleManager, _Safe_guardManager, _Safe_fallbackHandlerManager, _Safe_MAGIC_VALUE, _Safe_MAGIC_VALUE_BYTES, _Safe_initializeProtocolKit, _Safe_addPreValidatedSignature, _Safe_isReadyToExecute, _Safe_getFallbackHandlerContract;
 Object.defineProperty(exports, "__esModule", { value: true });
-const safe_core_sdk_types_1 = require("@safe-global/safe-core-sdk-types");
+const types_kit_1 = require("@safe-global/types-kit");
 const utils_1 = require("./contracts/utils");
 const config_1 = require("./contracts/config");
 const contractManager_1 = __importDefault(require("./managers/contractManager"));
@@ -32,6 +32,7 @@ const safeDeploymentContracts_1 = require("./contracts/safeDeploymentContracts")
 const SafeMessage_1 = __importDefault(require("./utils/messages/SafeMessage"));
 const satisfies_1 = __importDefault(require("semver/functions/satisfies"));
 const SafeProvider_1 = __importDefault(require("./SafeProvider"));
+const types_3 = require("./utils/types");
 const getPasskeyOwnerAddress_1 = __importDefault(require("./utils/passkeys/getPasskeyOwnerAddress"));
 const createPasskeyDeploymentTransaction_1 = __importDefault(require("./utils/passkeys/createPasskeyDeploymentTransaction"));
 const EQ_OR_GT_1_4_1 = '>=1.4.1';
@@ -67,7 +68,7 @@ class Safe {
          */
         this.getSafeMessageHash = async (messageHash) => {
             const safeAddress = await this.getAddress();
-            const safeVersion = await this.getContractVersion();
+            const safeVersion = this.getContractVersion();
             const chainId = await this.getChainId();
             return (0, utils_2.calculateSafeMessageHash)(safeAddress, messageHash, safeVersion, chainId);
         };
@@ -86,16 +87,18 @@ class Safe {
             const safeAddress = await this.getAddress();
             const fallbackHandler = await __classPrivateFieldGet(this, _Safe_instances, "m", _Safe_getFallbackHandlerContract).call(this);
             const signatureToCheck = signature && Array.isArray(signature) ? (0, utils_2.buildSignatureBytes)(signature) : signature;
-            // @ts-expect-error Argument of type isValidSignature(bytes32,bytes) is not assignable to parameter of type isValidSignature
-            const data = fallbackHandler.encode('isValidSignature(bytes32,bytes)', [
-                messageHash,
-                signatureToCheck
-            ]);
-            // @ts-expect-error Argument of type isValidSignature(bytes32,bytes) is not assignable to parameter of type isValidSignature
-            const bytesData = fallbackHandler.encode('isValidSignature(bytes,bytes)', [
-                messageHash,
-                signatureToCheck
-            ]);
+            // both bytes and bytes32 ends up being resolved to a bytes-like structure which is represented by a `0x` prefixed address.
+            // because there is an overload going on, named-tuples (https://www.typescriptlang.org/play/?ts=4.0.2#example/named-tuples) are used to solve the ambiguity.
+            const bytes32Tuple = [
+                (0, types_3.asHash)(messageHash),
+                (0, types_3.asHex)(signatureToCheck)
+            ];
+            const data = fallbackHandler.encode('isValidSignature', bytes32Tuple);
+            const bytesTuple = [
+                (0, types_3.asHash)(messageHash),
+                (0, types_3.asHex)(signatureToCheck)
+            ];
+            const bytesData = fallbackHandler.encode('isValidSignature', bytesTuple);
             try {
                 const isValidSignatureResponse = await Promise.all([
                     __classPrivateFieldGet(this, _Safe_safeProvider, "f").call({
@@ -117,6 +120,9 @@ class Safe {
                 return false;
             }
         };
+        this.getContractInfo = ({ contractAddress }) => {
+            return (0, config_1.getContractInfo)(contractAddress);
+        };
     }
     /**
      * Creates an instance of the Safe Core SDK.
@@ -206,7 +212,7 @@ class Safe {
      */
     async getAddress() {
         if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f")) {
-            const safeVersion = await this.getContractVersion();
+            const safeVersion = this.getContractVersion();
             if (!(0, utils_2.hasSafeFeature)(utils_2.SAFE_FEATURES.ACCOUNT_ABSTRACTION, safeVersion)) {
                 throw new Error('Account Abstraction functionality is not available for Safes with version lower than v1.3.0');
             }
@@ -221,7 +227,7 @@ class Safe {
         if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
             throw new Error('Safe is not deployed');
         }
-        return await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getAddress();
+        return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getAddress();
     }
     /**
      * Returns the ContractManager
@@ -244,16 +250,16 @@ class Safe {
      *
      * @returns The address of the MultiSend contract
      */
-    async getMultiSendAddress() {
-        return await __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendContract.getAddress();
+    getMultiSendAddress() {
+        return __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendContract.getAddress();
     }
     /**
      * Returns the address of the MultiSendCallOnly contract.
      *
      * @returns The address of the MultiSendCallOnly contract
      */
-    async getMultiSendCallOnlyAddress() {
-        return await __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendCallOnlyContract.getAddress();
+    getMultiSendCallOnlyAddress() {
+        return __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendCallOnlyContract.getAddress();
     }
     /**
      * Checks if the current Safe is deployed.
@@ -270,14 +276,14 @@ class Safe {
      *
      * @returns The Safe Singleton contract version
      */
-    async getContractVersion() {
+    getContractVersion() {
         if (__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
-            return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getVersion();
+            return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.safeVersion;
         }
         if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f")?.safeDeploymentConfig?.safeVersion) {
-            return Promise.resolve(__classPrivateFieldGet(this, _Safe_predictedSafe, "f").safeDeploymentConfig.safeVersion);
+            return __classPrivateFieldGet(this, _Safe_predictedSafe, "f").safeDeploymentConfig.safeVersion;
         }
-        return Promise.resolve(config_1.DEFAULT_SAFE_VERSION);
+        return config_1.DEFAULT_SAFE_VERSION;
     }
     /**
      * Returns the list of Safe owner accounts.
@@ -393,7 +399,7 @@ class Safe {
      * @throws "Invalid empty array of transactions"
      */
     async createTransaction({ transactions, onlyCalls = false, options }) {
-        const safeVersion = await this.getContractVersion();
+        const safeVersion = this.getContractVersion();
         if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f") && !(0, utils_2.hasSafeFeature)(utils_2.SAFE_FEATURES.ACCOUNT_ABSTRACTION, safeVersion)) {
             throw new Error('Account Abstraction functionality is not available for Safes with version lower than v1.3.0');
         }
@@ -408,10 +414,10 @@ class Safe {
             const multiSendData = (0, utils_3.encodeMultiSendData)(transactions.map(utils_3.standardizeMetaTransactionData));
             const multiSendTransaction = {
                 ...options,
-                to: await multiSendContract.getAddress(),
+                to: multiSendContract.getAddress(),
                 value: '0',
-                data: multiSendContract.encode('multiSend', [multiSendData]),
-                operation: safe_core_sdk_types_1.OperationType.DelegateCall
+                data: multiSendContract.encode('multiSend', [(0, types_3.asHex)(multiSendData)]),
+                operation: types_kit_1.OperationType.DelegateCall
             };
             newTransaction = multiSendTransaction;
         }
@@ -485,7 +491,7 @@ class Safe {
      */
     async getTransactionHash(safeTransaction) {
         const safeAddress = await this.getAddress();
-        const safeVersion = await this.getContractVersion();
+        const safeVersion = this.getContractVersion();
         const chainId = await this.getChainId();
         return (0, utils_2.calculateSafeTransactionHash)(safeAddress, safeTransaction.data, safeVersion, chainId);
     }
@@ -500,7 +506,7 @@ class Safe {
         const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
         if (isPasskeySigner && signerAddress) {
             let signature = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").signMessage(hash);
-            signature = (0, utils_2.adjustVInSignature)(types_1.SigningMethod.ETH_SIGN, signature, hash, signerAddress);
+            signature = await (0, utils_2.adjustVInSignature)(types_1.SigningMethod.ETH_SIGN, signature, hash, signerAddress);
             const safeSignature = new utils_2.EthSafeSignature(signerAddress, signature, true);
             return safeSignature;
         }
@@ -528,16 +534,15 @@ class Safe {
      * @returns The signed Safe message
      */
     async signMessage(message, signingMethod = types_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4, preimageSafeAddress) {
-        const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
         if (!signerAddress) {
-            throw new Error('SafeProvider must be initialized with a signer to use this method');
+            throw new Error('The protocol-kit requires a signer to use this method');
         }
-        const addressIsOwner = owners.some((owner) => signerAddress && (0, utils_2.sameString)(owner, signerAddress));
+        const addressIsOwner = await this.isOwner(signerAddress);
         if (!addressIsOwner) {
             throw new Error('Messages can only be signed by Safe owners');
         }
-        const safeVersion = await this.getContractVersion();
+        const safeVersion = this.getContractVersion();
         if (signingMethod === types_1.SigningMethod.SAFE_SIGNATURE &&
             (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_4_1) &&
             !preimageSafeAddress) {
@@ -587,7 +592,7 @@ class Safe {
     async signTypedData(eip712Data, methodVersion) {
         const safeEIP712Args = {
             safeAddress: await this.getAddress(),
-            safeVersion: await this.getContractVersion(),
+            safeVersion: this.getContractVersion(),
             chainId: await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getChainId(),
             data: eip712Data.data
         };
@@ -609,16 +614,15 @@ class Safe {
         const transaction = (0, utils_2.isSafeMultisigTransactionResponse)(safeTransaction)
             ? await this.toSafeTransactionType(safeTransaction)
             : safeTransaction;
-        const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
         if (!signerAddress) {
-            throw new Error('SafeProvider must be initialized with a signer to use this method');
+            throw new Error('The protocol-kit requires a signer to use this method');
         }
-        const addressIsOwner = owners.some((owner) => signerAddress && (0, utils_2.sameString)(owner, signerAddress));
+        const addressIsOwner = await this.isOwner(signerAddress);
         if (!addressIsOwner) {
             throw new Error('Transactions can only be signed by Safe owners');
         }
-        const safeVersion = await this.getContractVersion();
+        const safeVersion = this.getContractVersion();
         if (signingMethod === types_1.SigningMethod.SAFE_SIGNATURE &&
             (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_3_0) &&
             !preimageSafeAddress) {
@@ -640,7 +644,7 @@ class Safe {
             signature = await this.signTypedData(transaction, undefined);
         }
         else {
-            const safeVersion = await this.getContractVersion();
+            const safeVersion = this.getContractVersion();
             const chainId = await this.getChainId();
             if (!(0, utils_2.hasSafeFeature)(utils_2.SAFE_FEATURES.ETH_SIGN, safeVersion)) {
                 throw new Error('eth_sign is only supported by Safes >= v1.1.0');
@@ -677,12 +681,11 @@ class Safe {
         if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
             throw new Error('Safe is not deployed');
         }
-        const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
         if (!signerAddress) {
-            throw new Error('SafeProvider must be initialized with a signer to use this method');
+            throw new Error('The protocol-kit requires a signer to use this method');
         }
-        const addressIsOwner = owners.some((owner) => signerAddress && (0, utils_2.sameString)(owner, signerAddress));
+        const addressIsOwner = await this.isOwner(signerAddress);
         if (!addressIsOwner) {
             throw new Error('Transaction hashes can only be approved by Safe owners');
         }
@@ -699,12 +702,15 @@ class Safe {
      */
     async getOwnersWhoApprovedTx(txHash) {
         if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
-            throw new Error('Safe is not deployed');
+            return [];
         }
         const owners = await this.getOwners();
         const ownersWhoApproved = [];
         for (const owner of owners) {
-            const [approved] = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.approvedHashes([owner, txHash]);
+            const [approved] = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.approvedHashes([
+                (0, types_3.asHex)(owner),
+                (0, types_3.asHash)(txHash)
+            ]);
             if (approved > 0) {
                 ownersWhoApproved.push(owner);
             }
@@ -722,6 +728,10 @@ class Safe {
      * @throws "Current version of the Safe does not support the fallback handler functionality"
      */
     async createEnableFallbackHandlerTx(fallbackHandlerAddress, options) {
+        const safeVersion = await this.getContractVersion();
+        if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f") && !(0, utils_2.hasSafeFeature)(utils_2.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',
@@ -742,6 +752,10 @@ class Safe {
      * @throws "Current version of the Safe does not support the fallback handler functionality"
      */
     async createDisableFallbackHandlerTx(options) {
+        const safeVersion = await this.getContractVersion();
+        if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f") && !(0, utils_2.hasSafeFeature)(utils_2.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',
@@ -1009,12 +1023,12 @@ class Safe {
         for (const owner of ownersWhoApprovedTx) {
             signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(owner));
         }
-        const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
         if (!signerAddress) {
-            throw new Error('SafeProvider must be initialized with a signer to use this method');
+            throw new Error('The protocol-kit requires a signer to use this method');
         }
-        if (owners.includes(signerAddress)) {
+        const addressIsOwner = await this.isOwner(signerAddress);
+        if (addressIsOwner) {
             signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(signerAddress));
         }
         const isTxValid = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.isValidTransaction(signedSafeTransaction, {
@@ -1040,24 +1054,8 @@ class Safe {
         const transaction = (0, utils_2.isSafeMultisigTransactionResponse)(safeTransaction)
             ? await this.toSafeTransactionType(safeTransaction)
             : 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((0, utils_2.generatePreValidatedSignature)(owner));
-        }
-        const owners = await this.getOwners();
-        const threshold = await this.getThreshold();
-        const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
-        if (threshold > signedSafeTransaction.signatures.size &&
-            signerAddress &&
-            owners.includes(signerAddress)) {
-            signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(signerAddress));
-        }
-        if (threshold > signedSafeTransaction.signatures.size) {
-            const signaturesMissing = threshold - signedSafeTransaction.signatures.size;
-            throw new Error(`There ${signaturesMissing > 1 ? 'are' : 'is'} ${signaturesMissing} signature${signaturesMissing > 1 ? 's' : ''} missing`);
-        }
+        const signedSafeTransaction = await __classPrivateFieldGet(this, _Safe_instances, "m", _Safe_addPreValidatedSignature).call(this, transaction);
+        await __classPrivateFieldGet(this, _Safe_instances, "m", _Safe_isReadyToExecute).call(this, signedSafeTransaction);
         const value = BigInt(signedSafeTransaction.data.value);
         if (value !== 0n) {
             const balance = await this.getBalance();
@@ -1065,6 +1063,7 @@ class Safe {
                 throw new Error('Not enough Ether funds');
             }
         }
+        const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
         const txResponse = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.execTransaction(signedSafeTransaction, {
             from: signerAddress,
             ...options
@@ -1080,15 +1079,15 @@ class Safe {
      *
      */
     async getEncodedTransaction(safeTransaction) {
-        const safeVersion = await this.getContractVersion();
+        const safeVersion = this.getContractVersion();
         const chainId = await this.getChainId();
         const customContracts = __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks?.[chainId.toString()];
         const isL1SafeSingleton = __classPrivateFieldGet(this, _Safe_contractManager, "f").isL1SafeSingleton;
-        const safeSingletonContract = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSafeContract({
+        const safeSingletonContract = await (0, safeDeploymentContracts_1.getSafeContract)({
+            safeProvider: __classPrivateFieldGet(this, _Safe_safeProvider, "f"),
             safeVersion,
             isL1SafeSingleton,
-            customContractAbi: customContracts?.safeSingletonAbi,
-            customContractAddress: customContracts?.safeSingletonAddress
+            customContracts
         });
         const encodedTransaction = safeSingletonContract.encode('execTransaction', [
             safeTransaction.data.to,
@@ -1113,32 +1112,31 @@ class Safe {
      * @async
      * @param {SafeTransaction} safeTransaction - The Safe transaction to be wrapped into the deployment batch.
      * @param {TransactionOptions} [transactionOptions] - Optional. Options for the transaction, such as from, gas price, gas limit, etc.
-     * @param {string} [customSaltNonce] - Optional. a Custom salt nonce to be used for the deployment of the Safe. If not provided, a default value is used.
      * @returns {Promise<Transaction>} A promise that resolves to a Transaction object representing the prepared batch of transactions.
      * @throws Will throw an error if the safe is already deployed.
      *
      */
-    async wrapSafeTransactionIntoDeploymentBatch(safeTransaction, transactionOptions, customSaltNonce) {
+    async wrapSafeTransactionIntoDeploymentBatch(safeTransaction, transactionOptions) {
         const isSafeDeployed = await this.isSafeDeployed();
         // if the safe is already deployed throws an error
         if (isSafeDeployed) {
             throw new Error('Safe already deployed');
         }
         // we create the deployment transaction
-        const safeDeploymentTransaction = await this.createSafeDeploymentTransaction(customSaltNonce);
+        const safeDeploymentTransaction = await this.createSafeDeploymentTransaction();
         // First transaction of the batch: The Safe deployment Transaction
         const safeDeploymentBatchTransaction = {
             to: safeDeploymentTransaction.to,
             value: safeDeploymentTransaction.value,
             data: safeDeploymentTransaction.data,
-            operation: safe_core_sdk_types_1.OperationType.Call
+            operation: types_kit_1.OperationType.Call
         };
         // Second transaction of the batch: The Safe Transaction
         const safeBatchTransaction = {
             to: await this.getAddress(),
             value: '0',
             data: await this.getEncodedTransaction(safeTransaction),
-            operation: safe_core_sdk_types_1.OperationType.Call
+            operation: types_kit_1.OperationType.Call
         };
         // transactions for the batch
         const transactions = [safeDeploymentBatchTransaction, safeBatchTransaction];
@@ -1147,36 +1145,39 @@ class Safe {
         return safeDeploymentBatch;
     }
     /**
-     * Creates a Safe deployment transaction.
-     *
-     * This function prepares a transaction for the deployment of a Safe.
-     * Both the saltNonce and options parameters are optional, and if not
-     * provided, default values will be used.
-     *
-     * @async
-     * @param {string} [customSaltNonce] - Optional. a Custom salt nonce to be used for the deployment of the Safe. If not provided, a default value is used.
-     * @param {TransactionOptions} [options] - Optional. Options for the transaction, such as gas price, gas limit, etc.
-     * @returns {Promise<Transaction>} A promise that resolves to a Transaction object representing the prepared Safe deployment transaction.
+     * Creates a transaction to deploy a Safe Account.
      *
+     * @returns {Promise<Transaction>} Returns a promise that resolves to an Ethereum transaction with the fields `to`, `value`, and `data`, which can be used to deploy the Safe Account.
      */
-    async createSafeDeploymentTransaction(customSaltNonce, transactionOptions) {
+    async createSafeDeploymentTransaction() {
         if (!__classPrivateFieldGet(this, _Safe_predictedSafe, "f")) {
-            throw new Error('Predict Safe should be present');
+            throw new Error('Predict Safe should be present to build the Safe deployement transaction');
         }
-        const { safeAccountConfig, safeDeploymentConfig } = __classPrivateFieldGet(this, _Safe_predictedSafe, "f");
-        const safeVersion = await this.getContractVersion();
+        const { safeAccountConfig, safeDeploymentConfig = {} } = __classPrivateFieldGet(this, _Safe_predictedSafe, "f");
+        (0, utils_1.validateSafeAccountConfig)(safeAccountConfig);
+        (0, utils_1.validateSafeDeploymentConfig)(safeDeploymentConfig);
         const safeProvider = __classPrivateFieldGet(this, _Safe_safeProvider, "f");
         const chainId = await safeProvider.getChainId();
+        const safeVersion = safeDeploymentConfig?.safeVersion || config_1.DEFAULT_SAFE_VERSION;
+        const saltNonce = safeDeploymentConfig?.saltNonce || (0, utils_1.getChainSpecificDefaultSaltNonce)(chainId);
+        // we only check if the safe is deployed if safeVersion >= 1.3.0
+        if ((0, utils_2.hasSafeFeature)(utils_2.SAFE_FEATURES.ACCOUNT_ABSTRACTION, safeVersion)) {
+            const isSafeDeployed = await this.isSafeDeployed();
+            // if the safe is already deployed throws an error
+            if (isSafeDeployed) {
+                throw new Error('Safe already deployed');
+            }
+        }
         const isL1SafeSingleton = __classPrivateFieldGet(this, _Safe_contractManager, "f").isL1SafeSingleton;
         const customContracts = __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks?.[chainId.toString()];
-        const safeSingletonContract = await safeProvider.getSafeContract({
+        const safeSingletonContract = await (0, safeDeploymentContracts_1.getSafeContract)({
+            safeProvider,
             safeVersion,
             isL1SafeSingleton,
-            customContractAddress: customContracts?.safeSingletonAddress,
-            customContractAbi: customContracts?.safeSingletonAbi
+            customContracts
         });
         // we use the SafeProxyFactory.sol contract, see: https://github.com/safe-global/safe-contracts/blob/main/contracts/proxies/SafeProxyFactory.sol
-        const safeProxyFactoryContract = await (0, safeDeploymentContracts_1.getProxyFactoryContract)({
+        const safeProxyFactoryContract = await (0, safeDeploymentContracts_1.getSafeProxyFactoryContract)({
             safeProvider,
             safeVersion,
             customContracts
@@ -1188,17 +1189,13 @@ class Safe {
             safeAccountConfig: safeAccountConfig,
             customContracts
         });
-        const saltNonce = customSaltNonce ||
-            safeDeploymentConfig?.saltNonce ||
-            (0, utils_1.getChainSpecificDefaultSaltNonce)(chainId);
         const safeDeployTransactionData = {
-            ...transactionOptions, // optional transaction options like from, gasLimit, gasPrice...
-            to: await safeProxyFactoryContract.getAddress(),
+            to: safeProxyFactoryContract.getAddress(),
             value: '0',
             // we use the createProxyWithNonce method to create the Safe in a deterministic address, see: https://github.com/safe-global/safe-contracts/blob/main/contracts/proxies/SafeProxyFactory.sol#L52
             data: safeProxyFactoryContract.encode('createProxyWithNonce', [
-                await safeSingletonContract.getAddress(),
-                initializer, // call to the setup method to set the threshold & owners of the new Safe
+                (0, types_3.asHex)(safeSingletonContract.getAddress()),
+                (0, types_3.asHex)(initializer), // call to the setup method to set the threshold & owners of the new Safe
                 BigInt(saltNonce)
             ])
         };
@@ -1216,20 +1213,15 @@ class Safe {
      *
      */
     async createTransactionBatch(transactions, transactionOptions) {
-        const chainId = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getChainId();
         // we use the MultiSend contract to create the batch, see: https://github.com/safe-global/safe-contracts/blob/main/contracts/libraries/MultiSendCallOnly.sol
-        const multiSendCallOnlyContract = await (0, safeDeploymentContracts_1.getMultiSendCallOnlyContract)({
-            safeProvider: __classPrivateFieldGet(this, _Safe_safeProvider, "f"),
-            safeVersion: await this.getContractVersion(),
-            customContracts: __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks?.[chainId.toString()]
-        });
+        const multiSendCallOnlyContract = __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendCallOnlyContract;
         // multiSend method with the transactions encoded
         const batchData = multiSendCallOnlyContract.encode('multiSend', [
-            (0, utils_3.encodeMultiSendData)(transactions) // encoded transactions
+            (0, types_3.asHex)((0, utils_3.encodeMultiSendData)(transactions)) // encoded transactions
         ]);
         const transactionBatch = {
             ...transactionOptions, // optional transaction options like from, gasLimit, gasPrice...
-            to: await multiSendCallOnlyContract.getAddress(),
+            to: multiSendCallOnlyContract.getAddress(),
             value: '0',
             data: batchData
         };
@@ -1247,7 +1239,12 @@ _Safe_predictedSafe = new WeakMap(), _Safe_safeProvider = new WeakMap(), _Safe_c
  */
 async function _Safe_initializeProtocolKit(config) {
     const { provider, signer, isL1SafeSingleton, contractNetworks } = config;
-    __classPrivateFieldSet(this, _Safe_safeProvider, await SafeProvider_1.default.init(provider, signer, config_1.DEFAULT_SAFE_VERSION, contractNetworks), "f");
+    __classPrivateFieldSet(this, _Safe_safeProvider, await SafeProvider_1.default.init({
+        provider,
+        signer,
+        safeVersion: config_1.DEFAULT_SAFE_VERSION,
+        contractNetworks
+    }), "f");
     if ((0, types_2.isSafeConfigWithPredictedSafe)(config)) {
         __classPrivateFieldSet(this, _Safe_predictedSafe, config.predictedSafe, "f");
         __classPrivateFieldSet(this, _Safe_contractManager, await contractManager_1.default.init({
@@ -1265,8 +1262,13 @@ async function _Safe_initializeProtocolKit(config) {
             contractNetworks
         }, __classPrivateFieldGet(this, _Safe_safeProvider, "f")), "f");
     }
-    const safeVersion = await this.getContractVersion();
-    __classPrivateFieldSet(this, _Safe_safeProvider, await SafeProvider_1.default.init(provider, signer, safeVersion, contractNetworks), "f");
+    const safeVersion = this.getContractVersion();
+    __classPrivateFieldSet(this, _Safe_safeProvider, await SafeProvider_1.default.init({
+        provider,
+        signer,
+        safeVersion,
+        contractNetworks
+    }), "f");
     __classPrivateFieldSet(this, _Safe_ownerManager, new ownerManager_1.default(__classPrivateFieldGet(this, _Safe_safeProvider, "f"), __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract), "f");
     __classPrivateFieldSet(this, _Safe_moduleManager, new moduleManager_1.default(__classPrivateFieldGet(this, _Safe_safeProvider, "f"), __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract), "f");
     __classPrivateFieldSet(this, _Safe_guardManager, new guardManager_1.default(__classPrivateFieldGet(this, _Safe_safeProvider, "f"), __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract), "f");
@@ -1275,7 +1277,52 @@ async function _Safe_initializeProtocolKit(config) {
     if (isPasskeySigner) {
         const safeAddress = await this.getAddress();
         const owners = await this.getOwners();
-        __classPrivateFieldSet(this, _Safe_safeProvider, await SafeProvider_1.default.init(provider, signer, safeVersion, contractNetworks, safeAddress, owners), "f");
+        __classPrivateFieldSet(this, _Safe_safeProvider, await SafeProvider_1.default.init({
+            provider,
+            signer,
+            safeVersion,
+            contractNetworks,
+            safeAddress,
+            owners
+        }), "f");
+    }
+}, _Safe_addPreValidatedSignature = 
+/**
+ * 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 function _Safe_addPreValidatedSignature(transaction) {
+    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((0, utils_2.generatePreValidatedSignature)(owner));
+    }
+    const owners = await this.getOwners();
+    const threshold = await this.getThreshold();
+    const signerAddress = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getSignerAddress();
+    if (threshold > signedSafeTransaction.signatures.size &&
+        signerAddress &&
+        owners.includes(signerAddress)) {
+        signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(signerAddress));
+    }
+    return signedSafeTransaction;
+}, _Safe_isReadyToExecute = 
+/**
+ * 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 function _Safe_isReadyToExecute(transaction) {
+    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`);
     }
 }, _Safe_getFallbackHandlerContract = 
 /**
@@ -1287,7 +1334,7 @@ async function _Safe_getFallbackHandlerContract() {
     if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
         throw new Error('Safe is not deployed');
     }
-    const safeVersion = (await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getVersion()) ?? config_1.DEFAULT_SAFE_VERSION;
+    const safeVersion = __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.safeVersion ?? config_1.DEFAULT_SAFE_VERSION;
     const chainId = await __classPrivateFieldGet(this, _Safe_safeProvider, "f").getChainId();
     const compatibilityFallbackHandlerContract = await (0, safeDeploymentContracts_1.getCompatibilityFallbackHandlerContract)({
         safeProvider: __classPrivateFieldGet(this, _Safe_safeProvider, "f"),