@safe-global/protocol-kit 0.1.1 → 1.0.0

package/dist/src/Safe.d.ts

@@ -1,66 +1,20 @@
 import { BigNumber } from '@ethersproject/bignumber';
-import { EthAdapter, MetaTransactionData, SafeMultisigTransactionResponse, SafeTransaction, SafeTransactionDataPartial, SafeVersion, TransactionOptions, TransactionResult } from '@safe-global/safe-core-sdk-types';
+import { EthAdapter, SafeMultisigTransactionResponse, SafeSignature, SafeTransaction, SafeVersion, TransactionOptions, TransactionResult } from '@safe-global/safe-core-sdk-types';
 import ContractManager from './managers/contractManager';
-import { ContractNetworksConfig } from './types';
-import SafeSignature from './utils/signatures/SafeSignature';
+import { AddOwnerTxParams, ConnectSafeConfig, CreateTransactionProps, RemoveOwnerTxParams, SafeConfig, SwapOwnerTxParams } from './types';
 import { SafeTransactionOptionalProps } from './utils/transactions/types';
-export interface SafeConfig {
-    /** ethAdapter - Ethereum adapter */
-    ethAdapter: EthAdapter;
-    /** safeAddress - The address of the Safe account to use */
-    safeAddress: string;
-    /** isL1SafeMasterCopy - Forces to use the GnosisSafe L1 version of the contract instead of the L2 version */
-    isL1SafeMasterCopy?: boolean;
-    /** contractNetworks - Contract network configuration */
-    contractNetworks?: ContractNetworksConfig;
-}
-export interface ConnectSafeConfig {
-    /** ethAdapter - Ethereum adapter */
-    ethAdapter?: EthAdapter;
-    /** safeAddress - The address of the Safe account to use */
-    safeAddress?: string;
-    /** isL1SafeMasterCopy - Forces to use the GnosisSafe L1 version of the contract instead of the L2 version */
-    isL1SafeMasterCopy?: boolean;
-    /** contractNetworks - Contract network configuration */
-    contractNetworks?: ContractNetworksConfig;
-}
-export interface CreateTransactionProps {
-    /** safeTransactionData - The transaction or transaction array to process */
-    safeTransactionData: SafeTransactionDataPartial | MetaTransactionData[];
-    /** options - The transaction array optional properties */
-    options?: SafeTransactionOptionalProps;
-    /** onlyCalls - Forces the execution of the transaction array with MultiSendCallOnly contract */
-    onlyCalls?: boolean;
-}
-export interface AddOwnerTxParams {
-    /** ownerAddress - The address of the new owner */
-    ownerAddress: string;
-    /** threshold - The new threshold */
-    threshold?: number;
-}
-export interface RemoveOwnerTxParams {
-    /** ownerAddress - The address of the owner that will be removed */
-    ownerAddress: string;
-    /** threshold - The new threshold */
-    threshold?: number;
-}
-export interface SwapOwnerTxParams {
-    /** oldOwnerAddress - The old owner address */
-    oldOwnerAddress: string;
-    /** newOwnerAddress - The new owner address */
-    newOwnerAddress: string;
-}
 declare class Safe {
     #private;
     /**
      * 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"
      */
-    static create({ ethAdapter, safeAddress, isL1SafeMasterCopy, contractNetworks }: SafeConfig): Promise<Safe>;
+    static create(config: SafeConfig): Promise<Safe>;
     /**
      * Initializes the Safe Core SDK instance.
      * @param config - Safe configuration
@@ -73,17 +27,18 @@ declare class Safe {
     /**
      * Returns a new instance of the Safe Core SDK.
      * @param config - Connect Safe configuration
+     * @throws "A safeAddress and a predictedSafe cannot be connected at the same time"
      * @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"
      */
-    connect({ ethAdapter, safeAddress, isL1SafeMasterCopy, contractNetworks }: ConnectSafeConfig): Promise<Safe>;
+    connect(config: ConnectSafeConfig): Promise<Safe>;
     /**
      * Returns the address of the current SafeProxy contract.
      *
      * @returns The address of the SafeProxy contract
      */
-    getAddress(): string;
+    getAddress(): Promise<string>;
     /**
      * Returns the ContractManager
      *
@@ -108,6 +63,12 @@ declare class Safe {
      * @returns The address of the MultiSendCallOnly contract
      */
     getMultiSendCallOnlyAddress(): string;
+    /**
+     * Checks if the current Safe is deployed.
+     *
+     * @returns TRUE if the Safe contract is deployed
+     */
+    isSafeDeployed(): Promise<boolean>;
     /**
      * Returns the Safe Master Copy contract version.
      *

package/dist/src/Safe.js

@@ -13,22 +13,25 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _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;
 Object.defineProperty(exports, "__esModule", { value: true });
 const bignumber_1 = require("@ethersproject/bignumber");
 const safe_core_sdk_types_1 = require("@safe-global/safe-core-sdk-types");
-const utils_1 = require("./utils");
+const config_1 = require("./contracts/config");
+const utils_1 = require("./contracts/utils");
 const contractManager_1 = __importDefault(require("./managers/contractManager"));
 const fallbackHandlerManager_1 = __importDefault(require("./managers/fallbackHandlerManager"));
 const guardManager_1 = __importDefault(require("./managers/guardManager"));
 const moduleManager_1 = __importDefault(require("./managers/moduleManager"));
 const ownerManager_1 = __importDefault(require("./managers/ownerManager"));
-const signatures_1 = require("./utils/signatures");
-const SafeSignature_1 = __importDefault(require("./utils/signatures/SafeSignature"));
+const utils_2 = require("./utils");
+const utils_3 = require("./utils/signatures/utils");
 const SafeTransaction_1 = __importDefault(require("./utils/transactions/SafeTransaction"));
-const utils_2 = require("./utils/transactions/utils");
+const utils_4 = require("./utils/transactions/utils");
+const types_1 = require("./utils/types");
 class Safe {
     constructor() {
+        _Safe_predictedSafe.set(this, void 0);
         _Safe_ethAdapter.set(this, void 0);
         _Safe_contractManager.set(this, void 0);
         _Safe_ownerManager.set(this, void 0);
@@ -40,13 +43,14 @@ class Safe {
      * 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"
      */
-    static async create({ ethAdapter, safeAddress, isL1SafeMasterCopy, contractNetworks }) {
+    static async create(config) {
         const safeSdk = new Safe();
-        await safeSdk.init({ ethAdapter, safeAddress, isL1SafeMasterCopy, contractNetworks });
+        await safeSdk.init(config);
         return safeSdk;
     }
     /**
@@ -57,14 +61,26 @@ class Safe {
      * @throws "MultiSend contract is not deployed on the current network"
      * @throws "MultiSendCallOnly contract is not deployed on the current network"
      */
-    async init({ ethAdapter, safeAddress, isL1SafeMasterCopy, contractNetworks }) {
+    async init(config) {
+        const { ethAdapter, isL1SafeMasterCopy, contractNetworks } = config;
         __classPrivateFieldSet(this, _Safe_ethAdapter, ethAdapter, "f");
-        __classPrivateFieldSet(this, _Safe_contractManager, await contractManager_1.default.create({
-            ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
-            safeAddress,
-            isL1SafeMasterCopy,
-            contractNetworks
-        }), "f");
+        if ((0, types_1.isSafeConfigWithPredictedSafe)(config)) {
+            __classPrivateFieldSet(this, _Safe_predictedSafe, config.predictedSafe, "f");
+            __classPrivateFieldSet(this, _Safe_contractManager, await contractManager_1.default.create({
+                ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+                predictedSafe: __classPrivateFieldGet(this, _Safe_predictedSafe, "f"),
+                isL1SafeMasterCopy,
+                contractNetworks
+            }), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Safe_contractManager, await contractManager_1.default.create({
+                ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+                safeAddress: config.safeAddress,
+                isL1SafeMasterCopy,
+                contractNetworks
+            }), "f");
+        }
         __classPrivateFieldSet(this, _Safe_ownerManager, new ownerManager_1.default(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract), "f");
         __classPrivateFieldSet(this, _Safe_moduleManager, new moduleManager_1.default(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract), "f");
         __classPrivateFieldSet(this, _Safe_guardManager, new guardManager_1.default(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract), "f");
@@ -73,16 +89,43 @@ class Safe {
     /**
      * Returns a new instance of the Safe Core SDK.
      * @param config - Connect Safe configuration
+     * @throws "A safeAddress and a predictedSafe cannot be connected at the same time"
      * @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"
      */
-    async connect({ ethAdapter, safeAddress, isL1SafeMasterCopy, contractNetworks }) {
-        return await Safe.create({
+    async connect(config) {
+        const { ethAdapter, safeAddress, predictedSafe, isL1SafeMasterCopy, contractNetworks } = config;
+        const configProps = {
             ethAdapter: ethAdapter || __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
-            safeAddress: safeAddress || this.getAddress(),
             isL1SafeMasterCopy: isL1SafeMasterCopy || __classPrivateFieldGet(this, _Safe_contractManager, "f").isL1SafeMasterCopy,
             contractNetworks: contractNetworks || __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks
+        };
+        // A new existing Safe is connected to the Signer
+        if (safeAddress) {
+            return await Safe.create({
+                safeAddress,
+                ...configProps
+            });
+        }
+        // A new predicted Safe is connected to the Signer
+        if (predictedSafe) {
+            return await Safe.create({
+                predictedSafe,
+                ...configProps
+            });
+        }
+        // The previous predicted Safe is connected to a new Signer
+        if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f")) {
+            return await Safe.create({
+                predictedSafe: __classPrivateFieldGet(this, _Safe_predictedSafe, "f"),
+                ...configProps
+            });
+        }
+        // The previous existing Safe is connected to a new Signer
+        return await Safe.create({
+            safeAddress: await this.getAddress(),
+            ...configProps
         });
     }
     /**
@@ -90,8 +133,24 @@ class Safe {
      *
      * @returns The address of the SafeProxy contract
      */
-    getAddress() {
-        return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getAddress();
+    async getAddress() {
+        var _a;
+        if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f")) {
+            const safeVersion = await 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');
+            }
+            const chainId = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getChainId();
+            return (0, utils_1.predictSafeAddress)({
+                ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+                customContracts: (_a = __classPrivateFieldGet(this, _Safe_contractManager, "f").contractNetworks) === null || _a === void 0 ? void 0 : _a[chainId],
+                ...__classPrivateFieldGet(this, _Safe_predictedSafe, "f")
+            });
+        }
+        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            throw new Error('Safe is not deployed');
+        }
+        return Promise.resolve(__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getAddress());
     }
     /**
      * Returns the ContractManager
@@ -125,13 +184,30 @@ class Safe {
     getMultiSendCallOnlyAddress() {
         return __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendCallOnlyContract.getAddress();
     }
+    /**
+     * Checks if the current Safe is deployed.
+     *
+     * @returns TRUE if the Safe contract is deployed
+     */
+    async isSafeDeployed() {
+        const safeAddress = await this.getAddress();
+        const isSafeDeployed = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").isContractDeployed(safeAddress);
+        return isSafeDeployed;
+    }
     /**
      * Returns the Safe Master Copy contract version.
      *
      * @returns The Safe Master Copy contract version
      */
     async getContractVersion() {
-        return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getVersion();
+        var _a;
+        if (__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getVersion();
+        }
+        if ((_a = __classPrivateFieldGet(this, _Safe_predictedSafe, "f")) === null || _a === void 0 ? void 0 : _a.safeDeploymentConfig.safeVersion) {
+            return Promise.resolve(__classPrivateFieldGet(this, _Safe_predictedSafe, "f").safeDeploymentConfig.safeVersion);
+        }
+        return Promise.resolve(config_1.SAFE_LAST_VERSION);
     }
     /**
      * Returns the list of Safe owner accounts.
@@ -147,6 +223,9 @@ class Safe {
      * @returns The Safe nonce
      */
     async getNonce() {
+        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            return Promise.resolve(0);
+        }
         return __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.getNonce();
     }
     /**
@@ -171,7 +250,7 @@ class Safe {
      * @returns The ETH balance of the Safe
      */
     async getBalance() {
-        return __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getBalance(this.getAddress());
+        return __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getBalance(await this.getAddress());
     }
     /**
      * Returns the address of the FallbackHandler contract.
@@ -224,15 +303,19 @@ class Safe {
      * @throws "Invalid empty array of transactions"
      */
     async createTransaction({ safeTransactionData, onlyCalls = false, options }) {
-        if ((0, utils_1.isMetaTransactionArray)(safeTransactionData) && safeTransactionData.length === 0) {
+        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');
+        }
+        if ((0, utils_2.isMetaTransactionArray)(safeTransactionData) && safeTransactionData.length === 0) {
             throw new Error('Invalid empty array of transactions');
         }
         let newTransaction;
-        if ((0, utils_1.isMetaTransactionArray)(safeTransactionData) && safeTransactionData.length > 1) {
+        if ((0, utils_2.isMetaTransactionArray)(safeTransactionData) && safeTransactionData.length > 1) {
             const multiSendContract = onlyCalls
                 ? __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendCallOnlyContract
                 : __classPrivateFieldGet(this, _Safe_contractManager, "f").multiSendContract;
-            const multiSendData = (0, utils_2.encodeMultiSendData)(safeTransactionData.map(utils_2.standardizeMetaTransactionData));
+            const multiSendData = (0, utils_4.encodeMultiSendData)(safeTransactionData.map(utils_4.standardizeMetaTransactionData));
             const multiSendTransaction = {
                 ...options,
                 to: multiSendContract.getAddress(),
@@ -243,12 +326,25 @@ class Safe {
             newTransaction = multiSendTransaction;
         }
         else {
-            newTransaction = (0, utils_1.isMetaTransactionArray)(safeTransactionData)
+            newTransaction = (0, utils_2.isMetaTransactionArray)(safeTransactionData)
                 ? { ...options, ...safeTransactionData[0] }
                 : safeTransactionData;
         }
-        const standardizedTransaction = await (0, utils_2.standardizeSafeTransactionData)(__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract, __classPrivateFieldGet(this, _Safe_ethAdapter, "f"), newTransaction);
-        return new SafeTransaction_1.default(standardizedTransaction);
+        if (__classPrivateFieldGet(this, _Safe_predictedSafe, "f")) {
+            return new SafeTransaction_1.default(await (0, utils_4.standardizeSafeTransactionData)({
+                predictedSafe: __classPrivateFieldGet(this, _Safe_predictedSafe, "f"),
+                ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+                tx: newTransaction
+            }));
+        }
+        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            throw new Error('Safe is not deployed');
+        }
+        return new SafeTransaction_1.default(await (0, utils_4.standardizeSafeTransactionData)({
+            safeContract: __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract,
+            ethAdapter: __classPrivateFieldGet(this, _Safe_ethAdapter, "f"),
+            tx: newTransaction
+        }));
     }
     /**
      * Returns a Safe transaction ready to be signed by the owners that invalidates the pending Safe transaction/s with a specific nonce.
@@ -258,11 +354,11 @@ class Safe {
      */
     async createRejectionTransaction(nonce) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             nonce,
             value: '0',
             data: '0x',
-            safeTxGas: 0
+            safeTxGas: '0'
         };
         return this.createTransaction({ safeTransactionData });
     }
@@ -288,6 +384,9 @@ class Safe {
      * @returns The transaction 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;
@@ -299,7 +398,7 @@ class Safe {
      * @returns The Safe signature
      */
     async signTransactionHash(hash) {
-        return (0, signatures_1.generateSignature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), hash);
+        return (0, utils_3.generateSignature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), hash);
     }
     /**
      * Signs a transaction according to the EIP-712 using the current signer account.
@@ -310,12 +409,12 @@ class Safe {
      */
     async signTypedData(safeTransaction, methodVersion) {
         const safeTransactionEIP712Args = {
-            safeAddress: this.getAddress(),
+            safeAddress: await this.getAddress(),
             safeVersion: await this.getContractVersion(),
             chainId: await this.getEthAdapter().getChainId(),
             safeTransactionData: safeTransaction.data
         };
-        return (0, signatures_1.generateEIP712Signature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), safeTransactionEIP712Args, methodVersion);
+        return (0, utils_3.generateEIP712Signature)(__classPrivateFieldGet(this, _Safe_ethAdapter, "f"), safeTransactionEIP712Args, methodVersion);
     }
     /**
      * Adds the signature of the current signer to the Safe transaction object.
@@ -326,7 +425,7 @@ class Safe {
      * @throws "Transactions can only be signed by Safe owners"
      */
     async signTransaction(safeTransaction, signingMethod = 'eth_signTypedData_v4') {
-        const transaction = (0, utils_1.isSafeMultisigTransactionResponse)(safeTransaction)
+        const transaction = (0, utils_2.isSafeMultisigTransactionResponse)(safeTransaction)
             ? await this.toSafeTransactionType(safeTransaction)
             : safeTransaction;
         const owners = await this.getOwners();
@@ -334,7 +433,7 @@ class Safe {
         if (!signerAddress) {
             throw new Error('EthAdapter must be initialized with a signer to use this method');
         }
-        const addressIsOwner = owners.find((owner) => signerAddress && (0, utils_1.sameString)(owner, signerAddress));
+        const addressIsOwner = owners.find((owner) => signerAddress && (0, utils_2.sameString)(owner, signerAddress));
         if (!addressIsOwner) {
             throw new Error('Transactions can only be signed by Safe owners');
         }
@@ -350,7 +449,7 @@ class Safe {
         }
         else {
             const safeVersion = await this.getContractVersion();
-            if (!(0, utils_1.hasSafeFeature)(utils_1.SAFE_FEATURES.ETH_SIGN, safeVersion)) {
+            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);
@@ -375,12 +474,15 @@ class Safe {
      * @throws "Cannot specify gas and gasLimit together in transaction options"
      */
     async approveTransactionHash(hash, options) {
+        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_ethAdapter, "f").getSignerAddress();
         if (!signerAddress) {
             throw new Error('EthAdapter must be initialized with a signer to use this method');
         }
-        const addressIsOwner = owners.find((owner) => signerAddress && (0, utils_1.sameString)(owner, signerAddress));
+        const addressIsOwner = owners.find((owner) => signerAddress && (0, utils_2.sameString)(owner, signerAddress));
         if (!addressIsOwner) {
             throw new Error('Transaction hashes can only be approved by Safe owners');
         }
@@ -399,6 +501,9 @@ class Safe {
      * @returns The list of owners
      */
     async getOwnersWhoApprovedTx(txHash) {
+        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            throw new Error('Safe is not deployed');
+        }
         const owners = await this.getOwners();
         const ownersWhoApproved = [];
         for (const owner of owners) {
@@ -421,7 +526,7 @@ class Safe {
      */
     async createEnableFallbackHandlerTx(fallbackHandlerAddress, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_fallbackHandlerManager, "f").encodeEnableFallbackHandlerData(fallbackHandlerAddress),
             ...options
@@ -439,7 +544,7 @@ class Safe {
      */
     async createDisableFallbackHandlerTx(options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_fallbackHandlerManager, "f").encodeDisableFallbackHandlerData(),
             ...options
@@ -459,7 +564,7 @@ class Safe {
      */
     async createEnableGuardTx(guardAddress, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_guardManager, "f").encodeEnableGuardData(guardAddress),
             ...options
@@ -477,7 +582,7 @@ class Safe {
      */
     async createDisableGuardTx(options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_guardManager, "f").encodeDisableGuardData(),
             ...options
@@ -496,7 +601,7 @@ class Safe {
      */
     async createEnableModuleTx(moduleAddress, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_moduleManager, "f").encodeEnableModuleData(moduleAddress),
             ...options
@@ -515,7 +620,7 @@ class Safe {
      */
     async createDisableModuleTx(moduleAddress, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_moduleManager, "f").encodeDisableModuleData(moduleAddress),
             ...options
@@ -536,7 +641,7 @@ class Safe {
      */
     async createAddOwnerTx({ ownerAddress, threshold }, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_ownerManager, "f").encodeAddOwnerWithThresholdData(ownerAddress, threshold),
             ...options
@@ -557,7 +662,7 @@ class Safe {
      */
     async createRemoveOwnerTx({ ownerAddress, threshold }, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_ownerManager, "f").encodeRemoveOwnerData(ownerAddress, threshold),
             ...options
@@ -578,7 +683,7 @@ class Safe {
      */
     async createSwapOwnerTx({ oldOwnerAddress, newOwnerAddress }, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_ownerManager, "f").encodeSwapOwnerData(oldOwnerAddress, newOwnerAddress),
             ...options
@@ -597,7 +702,7 @@ class Safe {
      */
     async createChangeThresholdTx(threshold, options) {
         const safeTransactionData = {
-            to: this.getAddress(),
+            to: await this.getAddress(),
             value: '0',
             data: await __classPrivateFieldGet(this, _Safe_ownerManager, "f").encodeChangeThresholdData(threshold),
             ...options
@@ -618,16 +723,16 @@ class Safe {
             value: serviceTransactionResponse.value,
             data: serviceTransactionResponse.data || '0x',
             operation: serviceTransactionResponse.operation,
-            safeTxGas: serviceTransactionResponse.safeTxGas,
-            baseGas: serviceTransactionResponse.baseGas,
-            gasPrice: Number(serviceTransactionResponse.gasPrice),
+            safeTxGas: serviceTransactionResponse.safeTxGas.toString(),
+            baseGas: serviceTransactionResponse.baseGas.toString(),
+            gasPrice: serviceTransactionResponse.gasPrice,
             gasToken: serviceTransactionResponse.gasToken,
             refundReceiver: serviceTransactionResponse.refundReceiver,
             nonce: serviceTransactionResponse.nonce
         };
         const safeTransaction = await this.createTransaction({ safeTransactionData });
         (_a = serviceTransactionResponse.confirmations) === null || _a === void 0 ? void 0 : _a.map((confirmation) => {
-            const signature = new SafeSignature_1.default(confirmation.owner, confirmation.signature);
+            const signature = new utils_2.EthSafeSignature(confirmation.owner, confirmation.signature);
             safeTransaction.addSignature(signature);
         });
         return safeTransaction;
@@ -640,14 +745,17 @@ class Safe {
      * @returns TRUE if the Safe transaction can be executed successfully with no errors
      */
     async isValidTransaction(safeTransaction, options) {
-        const transaction = (0, utils_1.isSafeMultisigTransactionResponse)(safeTransaction)
+        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            throw new Error('Safe is not deployed');
+        }
+        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, signatures_1.generatePreValidatedSignature)(owner));
+            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(owner));
         }
         const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getSignerAddress();
@@ -655,7 +763,7 @@ class Safe {
             throw new Error('EthAdapter must be initialized with a signer to use this method');
         }
         if (owners.includes(signerAddress)) {
-            signedSafeTransaction.addSignature((0, signatures_1.generatePreValidatedSignature)(signerAddress));
+            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(signerAddress));
         }
         const isTxValid = await __classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract.isValidTransaction(signedSafeTransaction, {
             from: signerAddress,
@@ -674,19 +782,22 @@ class Safe {
      * @throws "Cannot specify gas and gasLimit together in transaction options"
      */
     async executeTransaction(safeTransaction, options) {
-        const transaction = (0, utils_1.isSafeMultisigTransactionResponse)(safeTransaction)
+        if (!__classPrivateFieldGet(this, _Safe_contractManager, "f").safeContract) {
+            throw new Error('Safe is not deployed');
+        }
+        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, signatures_1.generatePreValidatedSignature)(owner));
+            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(owner));
         }
         const owners = await this.getOwners();
         const signerAddress = await __classPrivateFieldGet(this, _Safe_ethAdapter, "f").getSignerAddress();
         if (signerAddress && owners.includes(signerAddress)) {
-            signedSafeTransaction.addSignature((0, signatures_1.generatePreValidatedSignature)(signerAddress));
+            signedSafeTransaction.addSignature((0, utils_3.generatePreValidatedSignature)(signerAddress));
         }
         const threshold = await this.getThreshold();
         if (threshold > signedSafeTransaction.signatures.size) {
@@ -710,6 +821,6 @@ class Safe {
         return txResponse;
     }
 }
-_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();
 exports.default = Safe;
 //# sourceMappingURL=Safe.js.map