@safe-global/protocol-kit 2.0.0 → 3.0.0-alpha.0

package/README.md

@@ -627,7 +627,7 @@ const safeTransaction = await safeSdk.createTransaction({ transactions })
 const txHash = await safeSdk.getTransactionHash(safeTransaction)
 ```
 
-### signTransactionHash
+### signHash
 
 Signs a hash using the current owner account.
 
@@ -639,7 +639,7 @@ const transactions: MetaTransactionData[] = [
 ]
 const safeTransaction = await safeSdk.createTransaction({ transactions })
 const txHash = await safeSdk.getTransactionHash(safeTransaction)
-const signature = await safeSdk.signTransactionHash(txHash)
+const signature = await safeSdk.signHash(txHash)
 ```
 
 ### signTypedData
@@ -673,11 +673,14 @@ const signedSafeTransaction = await safeSdk.signTransaction(safeTransaction)
 Optionally, an additional parameter can be passed to specify a different way of signing:
 
 ```js
-const signedSafeTransaction = await safeSdk.signTransaction(safeTransaction, 'eth_signTypedData')
+const signedSafeTransaction = await safeSdk.signTransaction(
+  safeTransaction,
+  SigningMethod.ETH_SIGN_TYPED_DATA
+)
 ```
 
 ```js
-const signedSafeTransaction = await safeSdk.signTransaction(safeTransaction, 'eth_sign') // default option.
+const signedSafeTransaction = await safeSdk.signTransaction(safeTransaction, SigningMethod.ETH_SIGN) // default option.
 ```
 
 ### approveTransactionHash

package/dist/src/Safe.d.ts

@@ -1,7 +1,8 @@
-import { EthAdapter, SafeMultisigTransactionResponse, SafeSignature, SafeTransaction, SafeVersion, TransactionOptions, TransactionResult, MetaTransactionData, Transaction } from '@safe-global/safe-core-sdk-types';
+import { EthAdapter, SafeMultisigTransactionResponse, SafeSignature, SafeTransaction, SafeVersion, TransactionOptions, TransactionResult, MetaTransactionData, Transaction, EIP712TypedData } from '@safe-global/safe-core-sdk-types';
 import ContractManager from './managers/contractManager';
-import { AddOwnerTxParams, ConnectSafeConfig, CreateTransactionProps, RemoveOwnerTxParams, SafeConfig, SwapOwnerTxParams } from './types';
+import { AddOwnerTxParams, ConnectSafeConfig, CreateTransactionProps, RemoveOwnerTxParams, SafeConfig, SigningMethodType, SwapOwnerTxParams } from './types';
 import { SafeTransactionOptionalProps } from './utils/transactions/types';
+import SafeMessage from './utils/messages/SafeMessage';
 declare class Safe {
     #private;
     /**
@@ -163,7 +164,7 @@ declare class Safe {
      * Returns the transaction hash of a Safe transaction.
      *
      * @param safeTransaction - The Safe transaction
-     * @returns The transaction hash of the Safe transaction
+     * @returns The hash of the Safe transaction
      */
     getTransactionHash(safeTransaction: SafeTransaction): Promise<string>;
     /**
@@ -172,24 +173,47 @@ declare class Safe {
      * @param hash - The hash to sign
      * @returns The Safe signature
      */
-    signTransactionHash(hash: string): Promise<SafeSignature>;
+    signHash(hash: string): Promise<SafeSignature>;
+    /**
+     * Returns a Safe message ready to be signed by the owners.
+     *
+     * @param message - The message
+     * @returns The Safe message
+     */
+    createMessage(message: string | EIP712TypedData): SafeMessage;
+    /**
+     * Returns the Safe message with a new signature
+     *
+     * @param message The message to be signed
+     * @param signingMethod The signature type
+     * @param preimageSafeAddress If the preimage is required, the address of the Safe that will be used to calculate the preimage.
+     * This field is mandatory for 1.4.1 contract versions Because the safe uses the old EIP-1271 interface which uses `bytes` instead of `bytes32` for the message
+     * we need to use the pre-image of the message to calculate the message hash
+     * https://github.com/safe-global/safe-contracts/blob/192c7dc67290940fcbc75165522bb86a37187069/test/core/Safe.Signatures.spec.ts#L229-L233
+     * @returns The signed Safe message
+     */
+    signMessage(message: SafeMessage, signingMethod?: SigningMethodType, preimageSafeAddress?: string): Promise<SafeMessage>;
     /**
      * Signs a transaction according to the EIP-712 using the current signer account.
      *
-     * @param safeTransaction - The Safe transaction to be signed
+     * @param eip712Data - The Safe Transaction or message hash to be signed
      * @param methodVersion - EIP-712 version. Optional
      * @returns The Safe signature
      */
-    signTypedData(safeTransaction: SafeTransaction, methodVersion?: 'v3' | 'v4'): Promise<SafeSignature>;
+    signTypedData(eip712Data: SafeTransaction | SafeMessage, methodVersion?: 'v3' | 'v4'): Promise<SafeSignature>;
     /**
      * Adds the signature of the current signer to the Safe transaction object.
      *
      * @param safeTransaction - The Safe transaction to be signed
      * @param signingMethod - Method followed to sign a transaction. Optional. Default value is "eth_sign"
+     * @param preimageSafeAddress - If the preimage is required, the address of the Safe that will be used to calculate the preimage
+     * This field is mandatory for 1.3.0 and 1.4.1 contract versions Because the safe uses the old EIP-1271 interface which uses `bytes` instead of `bytes32` for the message
+     * we need to use the pre-image of the message to calculate the message hash
+     * https://github.com/safe-global/safe-contracts/blob/192c7dc67290940fcbc75165522bb86a37187069/test/core/Safe.Signatures.spec.ts#L229-L233
      * @returns The signed Safe transaction
      * @throws "Transactions can only be signed by Safe owners"
      */
-    signTransaction(safeTransaction: SafeTransaction | SafeMultisigTransactionResponse, signingMethod?: 'eth_sign' | 'eth_signTypedData' | 'eth_signTypedData_v3' | 'eth_signTypedData_v4'): Promise<SafeTransaction>;
+    signTransaction(safeTransaction: SafeTransaction | SafeMultisigTransactionResponse, signingMethod?: SigningMethodType, preimageSafeAddress?: string): Promise<SafeTransaction>;
     /**
      * Approves on-chain a hash using the current signer account.
      *
@@ -389,5 +413,31 @@ declare class Safe {
      *
      */
     createTransactionBatch(transactions: MetaTransactionData[], transactionOptions?: TransactionOptions): Promise<Transaction>;
+    /**
+     * Get the fallback handler contract
+     *
+     * @returns The fallback Handler contract
+     */
+    private getFallbackHandlerContract;
+    /**
+     * Call the CompatibilityFallbackHandler getMessageHash method
+     *
+     * @param messageHash The hash of the message
+     * @returns Returns the Safe message hash to be signed
+     * @link https://github.com/safe-global/safe-contracts/blob/8ffae95faa815acf86ec8b50021ebe9f96abde10/contracts/handler/CompatibilityFallbackHandler.sol#L26-L28
+     */
+    getSafeMessageHash: (messageHash: string) => Promise<string>;
+    /**
+     * Call the CompatibilityFallbackHandler isValidSignature method
+     *
+     * @param messageHash The hash of the message
+     * @param signature The signature to be validated or '0x'. You can send as signature one of the following:
+     *  1) An array of SafeSignature. In this case the signatures are concatenated for validation (buildSignatureBytes())
+     *  2) The concatenated signatures as string
+     *  3) '0x' if you want to validate an onchain message (Approved hash)
+     * @returns A boolean indicating if the signature is valid
+     * @link https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol
+     */
+    isValidSignature: (messageHash: string, signature?: SafeSignature[] | string) => Promise<boolean>;
 }
 export default Safe;

package/dist/src/Safe.js

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Safe_predictedSafe, _Safe_ethAdapter, _Safe_contractManager, _Safe_ownerManager, _Safe_moduleManager, _Safe_guardManager, _Safe_fallbackHandlerManager;
+var _Safe_predictedSafe, _Safe_ethAdapter, _Safe_contractManager, _Safe_ownerManager, _Safe_moduleManager, _Safe_guardManager, _Safe_fallbackHandlerManager, _Safe_MAGIC_VALUE, _Safe_MAGIC_VALUE_BYTES;
 Object.defineProperty(exports, "__esModule", { value: true });
 const safe_core_sdk_types_1 = require("@safe-global/safe-core-sdk-types");
 const utils_1 = require("./contracts/utils");
@@ -23,12 +23,16 @@ const fallbackHandlerManager_1 = __importDefault(require("./managers/fallbackHan
 const guardManager_1 = __importDefault(require("./managers/guardManager"));
 const moduleManager_1 = __importDefault(require("./managers/moduleManager"));
 const ownerManager_1 = __importDefault(require("./managers/ownerManager"));
+const types_1 = require("./types");
 const utils_2 = require("./utils");
-const utils_3 = require("./utils/signatures/utils");
 const SafeTransaction_1 = __importDefault(require("./utils/transactions/SafeTransaction"));
-const utils_4 = require("./utils/transactions/utils");
-const types_1 = require("./utils/types");
+const utils_3 = require("./utils/transactions/utils");
+const types_2 = require("./utils/types");
 const safeDeploymentContracts_1 = require("./contracts/safeDeploymentContracts");
+const SafeMessage_1 = __importDefault(require("./utils/messages/SafeMessage"));
+const satisfies_1 = __importDefault(require("semver/functions/satisfies"));
+const EQ_OR_GT_1_4_1 = '>=1.4.1';
+const EQ_OR_GT_1_3_0 = '>=1.3.0';
 class Safe {
     constructor() {
         _Safe_predictedSafe.set(this, void 0);
@@ -38,6 +42,75 @@ class Safe {
         _Safe_moduleManager.set(this, void 0);
         _Safe_guardManager.set(this, void 0);
         _Safe_fallbackHandlerManager.set(this, void 0);
+        _Safe_MAGIC_VALUE.set(this, '0x1626ba7e');
+        _Safe_MAGIC_VALUE_BYTES.set(this, '0x20c13b0b'
+        /**
+         * Creates an instance of the Safe Core SDK.
+         * @param config - Ethers Safe configuration
+         * @returns The Safe Core SDK instance
+         * @throws "The SDK must be initialized with a safeAddress or a predictedSafe"
+         * @throws "SafeProxy contract is not deployed on the current network"
+         * @throws "MultiSend contract is not deployed on the current network"
+         * @throws "MultiSendCallOnly contract is not deployed on the current network"
+         */
+        );
+        /**
+         * Call the CompatibilityFallbackHandler getMessageHash method
+         *
+         * @param messageHash The hash of the message
+         * @returns Returns the Safe message hash to be signed
+         * @link https://github.com/safe-global/safe-contracts/blob/8ffae95faa815acf86ec8b50021ebe9f96abde10/contracts/handler/CompatibilityFallbackHandler.sol#L26-L28
+         */
+        this.getSafeMessageHash = async (messageHash) => {
+            const safeAddress = await this.getAddress();
+            const safeVersion = await this.getContractVersion();
+            const chainId = await this.getChainId();
+            return (0, utils_2.calculateSafeMessageHash)(safeAddress, messageHash, safeVersion, chainId);
+        };
+        /**
+         * Call the CompatibilityFallbackHandler isValidSignature method
+         *
+         * @param messageHash The hash of the message
+         * @param signature The signature to be validated or '0x'. You can send as signature one of the following:
+         *  1) An array of SafeSignature. In this case the signatures are concatenated for validation (buildSignatureBytes())
+         *  2) The concatenated signatures as string
+         *  3) '0x' if you want to validate an onchain message (Approved hash)
+         * @returns A boolean indicating if the signature is valid
+         * @link https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol
+         */
+        this.isValidSignature = async (messageHash, signature = '0x') => {
+            const safeAddress = await this.getAddress();
+            const fallbackHandler = await this.getFallbackHandlerContract();
+            const signatureToCheck = signature && Array.isArray(signature) ? (0, utils_2.buildSignatureBytes)(signature) : signature;
+            const data = fallbackHandler.encode('isValidSignature(bytes32,bytes)', [
+                messageHash,
+                signatureToCheck
+            ]);
+            const bytesData = fallbackHandler.encode('isValidSignature(bytes,bytes)', [
+                messageHash,
+                signatureToCheck
+            ]);
+            try {
+                const isValidSignatureResponse = await Promise.all([
+                    __classPrivateFieldGet(this, _Safe_ethAdapter, "f").call({
+                        from: safeAddress,
+                        to: safeAddress,
+                        data: data
+                    }),
+                    __classPrivateFieldGet(this, _Safe_ethAdapter, "f").call({
+                        from: safeAddress,
+                        to: safeAddress,
+                        data: bytesData
+                    })
+                ]);
+                return (!!isValidSignatureResponse.length &&
+                    (isValidSignatureResponse[0].slice(0, 10).toLowerCase() === __classPrivateFieldGet(this, _Safe_MAGIC_VALUE, "f") ||
+                        isValidSignatureResponse[1].slice(0, 10).toLowerCase() === __classPrivateFieldGet(this, _Safe_MAGIC_VALUE_BYTES, "f")));
+            }
+            catch (error) {
+                return false;
+            }
+        };
     }
     /**
      * Creates an instance of the Safe Core SDK.
@@ -64,7 +137,7 @@ class Safe {
     async init(config) {
         const { ethAdapter, isL1SafeSingleton, contractNetworks } = config;
         __classPrivateFieldSet(this, _Safe_ethAdapter, ethAdapter, "f");
-        if ((0, types_1.isSafeConfigWithPredictedSafe)(config)) {
+        if ((0, types_2.isSafeConfigWithPredictedSafe)(config)) {
             __classPrivateFieldSet(this, _Safe_predictedSafe, config.predictedSafe, "f");
             __classPrivateFieldSet(this, _Safe_contractManager, await contractManager_1.default.create({
                 ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
@@ -142,6 +215,7 @@ class Safe {
             const chainId = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getChainId();
             return (0, utils_1.predictSafeAddress)({
                 ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+                chainId,
                 customContracts: __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks?.[chainId.toString()],
                 ...__classPrivateFieldGet(this, _Safe_predictedSafe, "f")
             });
@@ -322,7 +396,7 @@ class Safe {
             const multiSendContract = onlyCalls
                 ? __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendCallOnlyContract
                 : __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendContract;
-            const multiSendData = (0, utils_4.encodeMultiSendData)(transactions.map(utils_4.standardizeMetaTransactionData));
+            const multiSendData = (0, utils_3.encodeMultiSendData)(transactions.map(utils_3.standardizeMetaTransactionData));
             const multiSendTransaction = {
                 ...options,
                 to: await multiSendContract.getAddress(),
@@ -336,7 +410,7 @@ class Safe {
             newTransaction = { ...options, ...transactions[0] };
         }
         if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f")) {
-            return new SafeTransaction_1.default(await (0, utils_4.standardizeSafeTransactionData)({
+            return new SafeTransaction_1.default(await (0, utils_3.standardizeSafeTransactionData)({
                 predictedSafe: __classPrivateFieldGet(this, _Safe_predictedSafe, "f"),
                 ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
                 tx: newTransaction,
@@ -346,7 +420,7 @@ class Safe {
         if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
             throw new Error('Safe is not deployed');
         }
-        return new SafeTransaction_1.default(await (0, utils_4.standardizeSafeTransactionData)({
+        return new SafeTransaction_1.default(await (0, utils_3.standardizeSafeTransactionData)({
             safeContract: __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract,
             ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
             tx: newTransaction,
@@ -398,15 +472,13 @@ class Safe {
      * Returns the transaction hash of a Safe transaction.
      *
      * @param safeTransaction - The Safe transaction
-     * @returns The transaction hash of the Safe transaction
+     * @returns The hash of the Safe transaction
      */
     async getTransactionHash(safeTransaction) {
-        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
-            throw new Error('Safe is not deployed');
-        }
-        const safeTransactionData = safeTransaction.data;
-        const txHash = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getTransactionHash(safeTransactionData);
-        return txHash;
+        const safeAddress = await this.getAddress();
+        const safeVersion = await this.getContractVersion();
+        const chainId = await this.getChainId();
+        return (0, utils_2.calculateSafeTransactionHash)(safeAddress, safeTransaction.data, safeVersion, chainId);
     }
     /**
      * Signs a hash using the current signer account.
@@ -414,34 +486,109 @@ class Safe {
      * @param hash - The hash to sign
      * @returns The Safe signature
      */
-    async signTransactionHash(hash) {
-        return (0, utils_3.generateSignature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), hash);
+    async signHash(hash) {
+        const signature = await (0, utils_2.generateSignature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), hash);
+        return signature;
+    }
+    /**
+     * Returns a Safe message ready to be signed by the owners.
+     *
+     * @param message - The message
+     * @returns The Safe message
+     */
+    createMessage(message) {
+        return new SafeMessage_1.default(message);
+    }
+    /**
+     * Returns the Safe message with a new signature
+     *
+     * @param message The message to be signed
+     * @param signingMethod The signature type
+     * @param preimageSafeAddress If the preimage is required, the address of the Safe that will be used to calculate the preimage.
+     * This field is mandatory for 1.4.1 contract versions Because the safe uses the old EIP-1271 interface which uses `bytes` instead of `bytes32` for the message
+     * we need to use the pre-image of the message to calculate the message hash
+     * https://github.com/safe-global/safe-contracts/blob/192c7dc67290940fcbc75165522bb86a37187069/test/core/Safe.Signatures.spec.ts#L229-L233
+     * @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_ethAdapter, "f").getSignerAddress();
+        if (!signerAddress) {
+            throw new Error('EthAdapter must be initialized with a signer to use this method');
+        }
+        const addressIsOwner = owners.some((owner) => signerAddress && (0, utils_2.sameString)(owner, signerAddress));
+        if (!addressIsOwner) {
+            throw new Error('Messages can only be signed by Safe owners');
+        }
+        const safeVersion = await this.getContractVersion();
+        if (signingMethod === types_1.SigningMethod.SAFE_SIGNATURE &&
+            (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_4_1) &&
+            !preimageSafeAddress) {
+            throw new Error('The parent Safe account address is mandatory for contract signatures');
+        }
+        let signature;
+        if (signingMethod === types_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4) {
+            signature = await this.signTypedData(message, 'v4');
+        }
+        else if (signingMethod === types_1.SigningMethod.ETH_SIGN_TYPED_DATA_V3) {
+            signature = await this.signTypedData(message, 'v3');
+        }
+        else if (signingMethod === types_1.SigningMethod.ETH_SIGN_TYPED_DATA) {
+            signature = await this.signTypedData(message, undefined);
+        }
+        else {
+            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');
+            }
+            let safeMessageHash;
+            if (signingMethod === types_1.SigningMethod.SAFE_SIGNATURE &&
+                preimageSafeAddress &&
+                (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_4_1)) {
+                const messageHashData = (0, utils_2.preimageSafeMessageHash)(preimageSafeAddress, (0, utils_2.hashSafeMessage)(message.data), safeVersion, chainId);
+                safeMessageHash = await this.getSafeMessageHash(messageHashData);
+            }
+            else {
+                safeMessageHash = await this.getSafeMessageHash((0, utils_2.hashSafeMessage)(message.data));
+            }
+            signature = await this.signHash(safeMessageHash);
+        }
+        const signedSafeMessage = this.createMessage(message.data);
+        message.signatures.forEach((signature) => {
+            signedSafeMessage.addSignature(signature);
+        });
+        signedSafeMessage.addSignature(signature);
+        return signedSafeMessage;
     }
     /**
      * Signs a transaction according to the EIP-712 using the current signer account.
      *
-     * @param safeTransaction - The Safe transaction to be signed
+     * @param eip712Data - The Safe Transaction or message hash to be signed
      * @param methodVersion - EIP-712 version. Optional
      * @returns The Safe signature
      */
-    async signTypedData(safeTransaction, methodVersion) {
-        const safeTransactionEIP712Args = {
+    async signTypedData(eip712Data, methodVersion) {
+        const safeEIP712Args = {
             safeAddress: await this.getAddress(),
             safeVersion: await this.getContractVersion(),
             chainId: await this.getEthAdapter().getChainId(),
-            safeTransactionData: safeTransaction.data
+            data: eip712Data.data
         };
-        return (0, utils_3.generateEIP712Signature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), safeTransactionEIP712Args, methodVersion);
+        return (0, utils_2.generateEIP712Signature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), safeEIP712Args, methodVersion);
     }
     /**
      * Adds the signature of the current signer to the Safe transaction object.
      *
      * @param safeTransaction - The Safe transaction to be signed
      * @param signingMethod - Method followed to sign a transaction. Optional. Default value is "eth_sign"
+     * @param preimageSafeAddress - If the preimage is required, the address of the Safe that will be used to calculate the preimage
+     * This field is mandatory for 1.3.0 and 1.4.1 contract versions Because the safe uses the old EIP-1271 interface which uses `bytes` instead of `bytes32` for the message
+     * we need to use the pre-image of the message to calculate the message hash
+     * https://github.com/safe-global/safe-contracts/blob/192c7dc67290940fcbc75165522bb86a37187069/test/core/Safe.Signatures.spec.ts#L229-L233
      * @returns The signed Safe transaction
      * @throws "Transactions can only be signed by Safe owners"
      */
-    async signTransaction(safeTransaction, signingMethod = 'eth_signTypedData_v4') {
+    async signTransaction(safeTransaction, signingMethod = types_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4, preimageSafeAddress) {
         const transaction = (0, utils_2.isSafeMultisigTransactionResponse)(safeTransaction)
             ? await this.toSafeTransactionType(safeTransaction)
             : safeTransaction;
@@ -454,23 +601,42 @@ class Safe {
         if (!addressIsOwner) {
             throw new Error('Transactions can only be signed by Safe owners');
         }
+        const safeVersion = await this.getContractVersion();
+        if (signingMethod === types_1.SigningMethod.SAFE_SIGNATURE &&
+            (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_3_0) &&
+            !preimageSafeAddress) {
+            throw new Error('The parent Safe account address is mandatory for contract signatures');
+        }
         let signature;
-        if (signingMethod === 'eth_signTypedData_v4') {
+        if (signingMethod === types_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4) {
             signature = await this.signTypedData(transaction, 'v4');
         }
-        else if (signingMethod === 'eth_signTypedData_v3') {
+        else if (signingMethod === types_1.SigningMethod.ETH_SIGN_TYPED_DATA_V3) {
             signature = await this.signTypedData(transaction, 'v3');
         }
-        else if (signingMethod === 'eth_signTypedData') {
-            signature = await this.signTypedData(transaction);
+        else if (signingMethod === types_1.SigningMethod.ETH_SIGN_TYPED_DATA) {
+            signature = await this.signTypedData(transaction, undefined);
         }
         else {
             const safeVersion = await 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');
             }
-            const txHash = await this.getTransactionHash(transaction);
-            signature = await this.signTransactionHash(txHash);
+            let txHash;
+            // IMPORTANT: because the safe uses the old EIP-1271 interface which uses `bytes` instead of `bytes32` for the message
+            // we need to use the pre-image of the transaction hash to calculate the message hash
+            // https://github.com/safe-global/safe-contracts/blob/192c7dc67290940fcbc75165522bb86a37187069/test/core/Safe.Signatures.spec.ts#L229-L233
+            if (signingMethod === types_1.SigningMethod.SAFE_SIGNATURE &&
+                (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_3_0) &&
+                preimageSafeAddress) {
+                const txHashData = (0, utils_2.preimageSafeTransactionHash)(preimageSafeAddress, safeTransaction.data, safeVersion, chainId);
+                txHash = await this.getSafeMessageHash(txHashData);
+            }
+            else {
+                txHash = await this.getTransactionHash(transaction);
+            }
+            signature = await this.signHash(txHash);
         }
         const signedSafeTransaction = await this.copyTransaction(transaction);
         signedSafeTransaction.addSignature(signature);
@@ -791,7 +957,7 @@ class Safe {
         const txHash = await this.getTransactionHash(signedSafeTransaction);
         const ownersWhoApprovedTx = await this.getOwnersWhoApprovedTx(txHash);
         for (const owner of ownersWhoApprovedTx) {
-            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(owner));
+            signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(owner));
         }
         const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getSignerAddress();
@@ -799,7 +965,7 @@ class Safe {
             throw new Error('EthAdapter must be initialized with a signer to use this method');
         }
         if (owners.includes(signerAddress)) {
-            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(signerAddress));
+            signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(signerAddress));
         }
         const isTxValid = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.isValidTransaction(signedSafeTransaction, {
             from: signerAddress,
@@ -828,7 +994,7 @@ class Safe {
         const txHash = await this.getTransactionHash(signedSafeTransaction);
         const ownersWhoApprovedTx = await this.getOwnersWhoApprovedTx(txHash);
         for (const owner of ownersWhoApprovedTx) {
-            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(owner));
+            signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(owner));
         }
         const owners = await this.getOwners();
         const threshold = await this.getThreshold();
@@ -836,7 +1002,7 @@ class Safe {
         if (threshold > signedSafeTransaction.signatures.size &&
             signerAddress &&
             owners.includes(signerAddress)) {
-            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(signerAddress));
+            signedSafeTransaction.addSignature((0, utils_2.generatePreValidatedSignature)(signerAddress));
         }
         if (threshold > signedSafeTransaction.signatures.size) {
             const signaturesMissing = threshold - signedSafeTransaction.signatures.size;
@@ -979,13 +1145,13 @@ class Safe {
             safeDeploymentConfig?.saltNonce ||
             (0, utils_1.getChainSpecificDefaultSaltNonce)(chainId);
         const safeDeployTransactionData = {
-            ...transactionOptions,
+            ...transactionOptions, // optional transaction options like from, gasLimit, gasPrice...
             to: await 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,
+                initializer, // call to the setup method to set the threshold & owners of the new Safe
                 saltNonce
             ])
         };
@@ -1012,17 +1178,35 @@ class Safe {
         });
         // multiSend method with the transactions encoded
         const batchData = multiSendCallOnlyContract.encode('multiSend', [
-            (0, utils_4.encodeMultiSendData)(transactions) // encoded transactions
+            (0, utils_3.encodeMultiSendData)(transactions) // encoded transactions
         ]);
         const transactionBatch = {
-            ...transactionOptions,
+            ...transactionOptions, // optional transaction options like from, gasLimit, gasPrice...
             to: await multiSendCallOnlyContract.getAddress(),
             value: '0',
             data: batchData
         };
         return transactionBatch;
     }
+    /**
+     * Get the fallback handler contract
+     *
+     * @returns The fallback Handler contract
+     */
+    async 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 chainId = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getChainId();
+        const compatibilityFallbackHandlerContract = await (0, safeDeploymentContracts_1.getCompatibilityFallbackHandlerContract)({
+            ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+            safeVersion,
+            customContracts: __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks?.[chainId.toString()]
+        });
+        return compatibilityFallbackHandlerContract;
+    }
 }
-_Safe_predictedSafe = new WeakMap(), _Safe_ethAdapter = new WeakMap(), _Safe_contractManager = new WeakMap(), _Safe_ownerManager = new WeakMap(), _Safe_moduleManager = new WeakMap(), _Safe_guardManager = new WeakMap(), _Safe_fallbackHandlerManager = new WeakMap();
+_Safe_predictedSafe = new WeakMap(), _Safe_ethAdapter = new WeakMap(), _Safe_contractManager = new WeakMap(), _Safe_ownerManager = new WeakMap(), _Safe_moduleManager = new WeakMap(), _Safe_guardManager = new WeakMap(), _Safe_fallbackHandlerManager = new WeakMap(), _Safe_MAGIC_VALUE = new WeakMap(), _Safe_MAGIC_VALUE_BYTES = new WeakMap();
 exports.default = Safe;
 //# sourceMappingURL=Safe.js.map