@safe-global/relay-kit 3.0.1 → 3.1.0-alpha.1

package/dist/src/packs/safe-4337/Safe4337Pack.d.ts

@@ -1,5 +1,6 @@
 import { SigningMethod } from '@safe-global/protocol-kit';
 import { RelayKitBasePack } from '../../RelayKitBasePack';
+import { SafeOperationResponse } from '@safe-global/safe-core-sdk-types';
 import EthSafeOperation from './SafeOperation';
 import { EstimateFeeProps, Safe4337CreateTransactionProps, Safe4337ExecutableProps, Safe4337InitOptions, Safe4337Options, UserOperationReceipt, UserOperationWithPayload } from './types';
 /**
@@ -25,7 +26,7 @@ export declare class Safe4337Pack extends RelayKitBasePack<{
      *
      * @param {Safe4337Options} options - The initialization parameters.
      */
-    constructor({ protocolKit, bundlerClient, publicClient, bundlerUrl, paymasterOptions, entryPointAddress, safe4337ModuleAddress }: Safe4337Options);
+    constructor({ protocolKit, bundlerClient, bundlerUrl, paymasterOptions, entryPointAddress, safe4337ModuleAddress }: Safe4337Options);
     /**
      * Initializes a Safe4337Pack class.
      * This method creates the protocolKit instance based on the input parameters.
@@ -57,18 +58,23 @@ export declare class Safe4337Pack extends RelayKitBasePack<{
     /**
      * Signs a safe operation.
      *
-     * @param {EthSafeOperation} safeOperation - The SafeOperation to sign.
+     * @param {EthSafeOperation | SafeOperationResponse} safeOperation - The SafeOperation to sign. It can be:
+     * - A response from the API (Tx Service)
+     * - An instance of EthSafeOperation
      * @param {SigningMethod} signingMethod - The signing method to use.
      * @return {Promise<EthSafeOperation>} The Promise object will resolve to the signed SafeOperation.
      */
-    signSafeOperation(safeOperation: EthSafeOperation, signingMethod?: SigningMethod): Promise<EthSafeOperation>;
+    signSafeOperation(safeOperation: EthSafeOperation | SafeOperationResponse, signingMethod?: SigningMethod): Promise<EthSafeOperation>;
     /**
      * Executes the relay transaction.
      *
-     * @param {EthSafeOperation} safeOperation - The SafeOperation to execute.
+     * @param {Safe4337ExecutableProps} props - The parameters for the transaction execution.
+     * @param {EthSafeOperation | SafeOperationResponse} props.executable - The SafeOperation to execute. It can be:
+     * - A response from the API (Tx Service)
+     * - An instance of EthSafeOperation
      * @return {Promise<string>} The user operation hash.
      */
-    executeTransaction({ executable: safeOperation }: Safe4337ExecutableProps): Promise<string>;
+    executeTransaction({ executable }: Safe4337ExecutableProps): Promise<string>;
     /**
      * Return a UserOperation based on a hash (userOpHash) returned by eth_sendUserOperation
      *

package/dist/src/packs/safe-4337/Safe4337Pack.js

@@ -36,7 +36,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Safe4337Pack_instances, _Safe4337Pack_BUNDLER_URL, _Safe4337Pack_ENTRYPOINT_ADDRESS, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, _Safe4337Pack_bundlerClient, _Safe4337Pack_publicClient, _Safe4337Pack_paymasterOptions, _Safe4337Pack_getSafeUserOperationHash, _Safe4337Pack_sendUserOperation, _Safe4337Pack_signTypedData, _Safe4337Pack_getAccountNonce, _Safe4337Pack_encodeExecuteUserOpCallData, _Safe4337Pack_encodeMultiSendCallData;
+var _Safe4337Pack_instances, _Safe4337Pack_BUNDLER_URL, _Safe4337Pack_ENTRYPOINT_ADDRESS, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, _Safe4337Pack_bundlerClient, _Safe4337Pack_paymasterOptions, _Safe4337Pack_toSafeOperation, _Safe4337Pack_getSafeNonceFromEntrypoint, _Safe4337Pack_encodeExecuteUserOpCallData;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Safe4337Pack = void 0;
 const ethers_1 = require("ethers");
@@ -48,8 +48,20 @@ const safe_modules_deployments_1 = require("@safe-global/safe-modules-deployment
 const SafeOperation_1 = __importDefault(require("./SafeOperation"));
 const constants_1 = require("./constants");
 const utils_1 = require("./utils");
+const entrypoint_1 = require("./utils/entrypoint");
 const PimlicoFeeEstimator_1 = require("./estimators/PimlicoFeeEstimator");
 const MAX_ERC20_AMOUNT_TO_APPROVE = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+const EQ_OR_GT_1_4_1 = '>=1.4.1';
+/**
+  Some of the contracts used in the PoC app are still experimental, and not included in
+  the production deployment packages, thus we need to hardcode their addresses here.
+  Deployment commit: https://github.com/safe-global/safe-modules/commit/3853f34f31837e0a0aee47a4452564278f8c62ba
+*/
+// FIXME: use the production deployment packages instead of a hardcoded address
+const SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS = '0x608Cf2e3412c6BDA14E6D8A0a7D27c4240FeD6F1';
+// FIXME: use the production deployment packages instead of a hardcoded address
+// Sepolia only
+const P256_VERIFIER_ADDRESS = '0xcA89CBa4813D5B40AeC6E57A30d0Eeb500d6531b'; // FCLP256Verifier
 /**
  * Safe4337Pack class that extends RelayKitBasePack.
  * This class provides an implementation of the ERC-4337 that enables Safe accounts to wrk with UserOperations.
@@ -65,18 +77,16 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      *
      * @param {Safe4337Options} options - The initialization parameters.
      */
-    constructor({ protocolKit, bundlerClient, publicClient, bundlerUrl, paymasterOptions, entryPointAddress, safe4337ModuleAddress }) {
+    constructor({ protocolKit, bundlerClient, bundlerUrl, paymasterOptions, entryPointAddress, safe4337ModuleAddress }) {
         super(protocolKit);
         _Safe4337Pack_instances.add(this);
         _Safe4337Pack_BUNDLER_URL.set(this, void 0);
         _Safe4337Pack_ENTRYPOINT_ADDRESS.set(this, void 0);
         _Safe4337Pack_SAFE_4337_MODULE_ADDRESS.set(this, '0x');
         _Safe4337Pack_bundlerClient.set(this, void 0);
-        _Safe4337Pack_publicClient.set(this, void 0);
         _Safe4337Pack_paymasterOptions.set(this, void 0);
         __classPrivateFieldSet(this, _Safe4337Pack_BUNDLER_URL, bundlerUrl, "f");
         __classPrivateFieldSet(this, _Safe4337Pack_bundlerClient, bundlerClient, "f");
-        __classPrivateFieldSet(this, _Safe4337Pack_publicClient, publicClient, "f");
         __classPrivateFieldSet(this, _Safe4337Pack_paymasterOptions, paymasterOptions, "f");
         __classPrivateFieldSet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, entryPointAddress, "f");
         __classPrivateFieldSet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, safe4337ModuleAddress, "f");
@@ -92,17 +102,20 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      * @return {Promise<Safe4337Pack>} The Promise object that will be resolved into an instance of Safe4337Pack.
      */
     static async init(initOptions) {
-        const { provider, signer, options, bundlerUrl, rpcUrl, customContracts, paymasterOptions } = initOptions;
+        const { provider, signer, options, bundlerUrl, customContracts, paymasterOptions } = initOptions;
         let protocolKit;
         const bundlerClient = (0, utils_1.getEip4337BundlerProvider)(bundlerUrl);
-        const publicClient = (0, utils_1.getEip1193Provider)(rpcUrl);
         const chainId = await bundlerClient.send(constants_1.RPC_4337_CALLS.CHAIN_ID, []);
         let addModulesLibAddress = customContracts?.addModulesLibAddress;
         const network = parseInt(chainId, 16).toString();
+        const safeModulesVersion = initOptions.safeModulesVersion || constants_1.DEFAULT_SAFE_MODULES_VERSION;
+        if ((0, satisfies_1.default)(safeModulesVersion, entrypoint_1.EQ_OR_GT_0_3_0)) {
+            throw new Error(`Incompatibility detected: Safe modules version ${safeModulesVersion} is not supported. The SDK can use 0.2.0 only.`);
+        }
         if (!addModulesLibAddress) {
             const addModulesDeployment = (0, safe_modules_deployments_1.getAddModulesLibDeployment)({
                 released: true,
-                version: initOptions.safeModulesVersion || constants_1.DEFAULT_SAFE_MODULES_VERSION,
+                version: safeModulesVersion,
                 network
             });
             addModulesLibAddress = addModulesDeployment?.networkAddresses[network];
@@ -111,13 +124,13 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
         if (!safe4337ModuleAddress) {
             const safe4337ModuleDeployment = (0, safe_modules_deployments_1.getSafe4337ModuleDeployment)({
                 released: true,
-                version: initOptions.safeModulesVersion || constants_1.DEFAULT_SAFE_MODULES_VERSION,
+                version: safeModulesVersion,
                 network
             });
             safe4337ModuleAddress = safe4337ModuleDeployment?.networkAddresses[network];
         }
         if (!addModulesLibAddress || !safe4337ModuleAddress) {
-            throw new Error(`Safe4337Module and/or AddModulesLib not available for chain ${network} and modules version ${constants_1.DEFAULT_SAFE_MODULES_VERSION}`);
+            throw new Error(`Safe4337Module and/or AddModulesLib not available for chain ${network} and modules version ${safeModulesVersion}`);
         }
         // Existing Safe
         if ('safeAddress' in options) {
@@ -127,7 +140,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
                 safeAddress: options.safeAddress
             });
             const safeVersion = await protocolKit.getContractVersion();
-            const isSafeVersion4337Compatible = (0, satisfies_1.default)(safeVersion, '>=1.4.1');
+            const isSafeVersion4337Compatible = (0, satisfies_1.default)(safeVersion, EQ_OR_GT_1_4_1);
             if (!isSafeVersion4337Compatible) {
                 throw new Error(`Incompatibility detected: The current Safe Account version (${safeVersion}) is not supported. EIP-4337 requires the Safe to use at least v1.4.1.`);
             }
@@ -147,41 +160,74 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
             if (!options.owners || !options.threshold) {
                 throw new Error('Owners and threshold are required to deploy a new Safe');
             }
-            let deploymentTo = addModulesLibAddress;
-            let deploymentData = constants_1.INTERFACES.encodeFunctionData('enableModules', [[safe4337ModuleAddress]]);
+            const safeVersion = options.safeVersion || constants_1.DEFAULT_SAFE_VERSION;
+            // we need to create a batch to setup the 4337 Safe Account
+            // first setup transaction: Enable 4337 module
+            const enable4337ModuleTransaction = {
+                to: addModulesLibAddress,
+                value: '0',
+                data: constants_1.INTERFACES.encodeFunctionData('enableModules', [[safe4337ModuleAddress]]),
+                operation: safe_core_sdk_types_1.OperationType.DelegateCall // DelegateCall required for enabling the 4337 module
+            };
+            const setupTransactions = [enable4337ModuleTransaction];
             const { isSponsored, paymasterTokenAddress } = paymasterOptions || {};
             const isApproveTransactionRequired = !!paymasterOptions && !isSponsored && !!paymasterTokenAddress;
             if (isApproveTransactionRequired) {
                 const { paymasterAddress, amountToApprove = MAX_ERC20_AMOUNT_TO_APPROVE } = paymasterOptions;
-                const enable4337ModulesTransaction = {
-                    to: addModulesLibAddress,
-                    value: '0',
-                    data: constants_1.INTERFACES.encodeFunctionData('enableModules', [[safe4337ModuleAddress]]),
-                    operation: safe_core_sdk_types_1.OperationType.DelegateCall // DelegateCall required for enabling the 4337 module
-                };
+                // second transaction: approve ERC-20 paymaster token
                 const approveToPaymasterTransaction = {
                     to: paymasterTokenAddress,
                     data: constants_1.INTERFACES.encodeFunctionData('approve', [paymasterAddress, amountToApprove]),
                     value: '0',
                     operation: safe_core_sdk_types_1.OperationType.Call // Call for approve
                 };
-                const setupBatch = [enable4337ModulesTransaction, approveToPaymasterTransaction];
-                const batchData = constants_1.INTERFACES.encodeFunctionData('multiSend', [
-                    (0, protocol_kit_1.encodeMultiSendData)(setupBatch)
-                ]);
+                setupTransactions.push(approveToPaymasterTransaction);
+            }
+            const safeProvider = await protocol_kit_1.SafeProvider.init(provider, signer, safeVersion);
+            // third transaction: passkey support via shared signer SafeWebAuthnSharedSigner
+            // see: https://github.com/safe-global/safe-modules/blob/main/modules/passkey/contracts/4337/experimental/README.md
+            const isPasskeySigner = await safeProvider.isPasskeySigner();
+            if (isPasskeySigner) {
+                const passkeySigner = (await safeProvider.getExternalSigner());
+                if (!options.owners.includes(SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS)) {
+                    options.owners.push(SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS);
+                }
+                const passkeyOwnerConfiguration = {
+                    ...passkeySigner.coordinates,
+                    verifiers: P256_VERIFIER_ADDRESS
+                };
+                const sharedSignerTransaction = {
+                    to: SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS,
+                    value: '0',
+                    data: constants_1.INTERFACES.encodeFunctionData('configure', [passkeyOwnerConfiguration]),
+                    operation: safe_core_sdk_types_1.OperationType.DelegateCall // DelegateCall required into the SafeWebAuthnSharedSigner instance in order for it to set its configuration.
+                };
+                setupTransactions.push(sharedSignerTransaction);
+            }
+            let deploymentTo;
+            let deploymentData;
+            const isBatch = setupTransactions.length > 1;
+            if (isBatch) {
                 const multiSendContract = await (0, protocol_kit_1.getMultiSendContract)({
-                    safeProvider: new protocol_kit_1.SafeProvider({ provider, signer }),
-                    safeVersion: options.safeVersion || constants_1.DEFAULT_SAFE_VERSION
+                    safeProvider,
+                    safeVersion
                 });
+                const batchData = constants_1.INTERFACES.encodeFunctionData('multiSend', [
+                    (0, protocol_kit_1.encodeMultiSendData)(setupTransactions)
+                ]);
                 deploymentTo = await multiSendContract.getAddress();
                 deploymentData = batchData;
             }
+            else {
+                deploymentTo = enable4337ModuleTransaction.to;
+                deploymentData = enable4337ModuleTransaction.data;
+            }
             protocolKit = await protocol_kit_1.default.init({
                 provider,
                 signer,
                 predictedSafe: {
                     safeDeploymentConfig: {
-                        safeVersion: options.safeVersion || constants_1.DEFAULT_SAFE_VERSION,
+                        safeVersion,
                         saltNonce: options.saltNonce || undefined
                     },
                     safeAccountConfig: {
@@ -197,20 +243,32 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
                 }
             });
         }
-        let supportedEntryPoints;
-        if (!customContracts?.entryPointAddress) {
-            supportedEntryPoints = await bundlerClient.send(constants_1.RPC_4337_CALLS.SUPPORTED_ENTRY_POINTS, []);
+        let selectedEntryPoint;
+        if (customContracts?.entryPointAddress) {
+            const requiredSafeModulesVersion = (0, entrypoint_1.entryPointToSafeModules)(customContracts?.entryPointAddress);
+            if (!(0, satisfies_1.default)(safeModulesVersion, requiredSafeModulesVersion))
+                throw new Error(`The selected entrypoint ${customContracts?.entryPointAddress} is not compatible with version ${safeModulesVersion} of Safe modules`);
+            selectedEntryPoint = customContracts?.entryPointAddress;
+        }
+        else {
+            const supportedEntryPoints = await bundlerClient.send(constants_1.RPC_4337_CALLS.SUPPORTED_ENTRY_POINTS, []);
             if (!supportedEntryPoints.length) {
                 throw new Error('No entrypoint provided or available through the bundler');
             }
+            selectedEntryPoint = supportedEntryPoints.find((entryPoint) => {
+                const requiredSafeModulesVersion = (0, entrypoint_1.entryPointToSafeModules)(entryPoint);
+                return (0, satisfies_1.default)(safeModulesVersion, requiredSafeModulesVersion);
+            });
+            if (!selectedEntryPoint) {
+                throw new Error(`Incompatibility detected: None of the entrypoints provided by the bundler is compatible with the Safe modules version ${safeModulesVersion}`);
+            }
         }
         return new Safe4337Pack({
             protocolKit,
             bundlerClient,
-            publicClient,
             paymasterOptions,
             bundlerUrl,
-            entryPointAddress: customContracts?.entryPointAddress || supportedEntryPoints[0],
+            entryPointAddress: selectedEntryPoint,
             safe4337ModuleAddress
         });
     }
@@ -223,6 +281,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      * @return {Promise<EthSafeOperation>} The Promise object that will be resolved into the gas estimation.
      */
     async getEstimateFee({ safeOperation, feeEstimator = new PimlicoFeeEstimator_1.PimlicoFeeEstimator() }) {
+        const threshold = await this.protocolKit.getThreshold();
         const setupEstimationData = await feeEstimator?.setupEstimation?.({
             bundlerUrl: __classPrivateFieldGet(this, _Safe4337Pack_BUNDLER_URL, "f"),
             entryPoint: __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f"),
@@ -231,7 +290,10 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
         if (setupEstimationData) {
             safeOperation.addEstimations(setupEstimationData);
         }
-        const estimateUserOperationGas = await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.ESTIMATE_USER_OPERATION_GAS, [(0, utils_1.userOperationToHexValues)(safeOperation.toUserOperation()), __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f")]);
+        const estimateUserOperationGas = await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.ESTIMATE_USER_OPERATION_GAS, [
+            (0, utils_1.userOperationToHexValues)((0, utils_1.addDummySignature)(safeOperation.toUserOperation(), SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS, threshold)),
+            __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f")
+        ]);
         if (estimateUserOperationGas) {
             safeOperation.addEstimations({
                 preVerificationGas: BigInt(estimateUserOperationGas.preVerificationGas),
@@ -252,7 +314,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
                 throw new Error('No paymaster url provided for a sponsored transaction');
             }
             const paymasterEstimation = await feeEstimator?.getPaymasterEstimation?.({
-                userOperation: safeOperation.toUserOperation(),
+                userOperation: (0, utils_1.addDummySignature)(safeOperation.toUserOperation(), SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS, threshold),
                 paymasterUrl: __classPrivateFieldGet(this, _Safe4337Pack_paymasterOptions, "f").paymasterUrl,
                 entryPoint: __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f"),
                 sponsorshipPolicyId: __classPrivateFieldGet(this, _Safe4337Pack_paymasterOptions, "f").sponsorshipPolicyId
@@ -274,7 +336,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      */
     async createTransaction({ transactions, options = {} }) {
         const safeAddress = await this.protocolKit.getAddress();
-        const nonce = await __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_getAccountNonce).call(this, safeAddress);
+        const nonce = await __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_getSafeNonceFromEntrypoint).call(this, safeAddress);
         const { amountToApprove, validUntil, validAfter, feeEstimator } = options;
         if (amountToApprove) {
             if (!__classPrivateFieldGet(this, _Safe4337Pack_paymasterOptions, "f") || !__classPrivateFieldGet(this, _Safe4337Pack_paymasterOptions, "f").paymasterTokenAddress) {
@@ -296,7 +358,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
             ? __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_encodeExecuteUserOpCallData).call(this, {
                 to: multiSendAddress,
                 value: '0',
-                data: __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_encodeMultiSendCallData).call(this, transactions),
+                data: (0, utils_1.encodeMultiSendCallData)(transactions),
                 operation: safe_core_sdk_types_1.OperationType.DelegateCall
             })
             : __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_encodeExecuteUserOpCallData).call(this, transactions[0]);
@@ -319,6 +381,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
             userOperation.initCode = await this.protocolKit.getInitCode();
         }
         const safeOperation = new SafeOperation_1.default(userOperation, {
+            moduleAddress: __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f"),
             entryPoint: __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f"),
             validUntil,
             validAfter
@@ -331,37 +394,60 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
     /**
      * Signs a safe operation.
      *
-     * @param {EthSafeOperation} safeOperation - The SafeOperation to sign.
+     * @param {EthSafeOperation | SafeOperationResponse} safeOperation - The SafeOperation to sign. It can be:
+     * - A response from the API (Tx Service)
+     * - An instance of EthSafeOperation
      * @param {SigningMethod} signingMethod - The signing method to use.
      * @return {Promise<EthSafeOperation>} The Promise object will resolve to the signed SafeOperation.
      */
     async signSafeOperation(safeOperation, signingMethod = protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4) {
+        let safeOp;
+        if ((0, safe_core_sdk_types_1.isSafeOperationResponse)(safeOperation)) {
+            safeOp = __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_toSafeOperation).call(this, safeOperation);
+        }
+        else {
+            safeOp = safeOperation;
+        }
         const owners = await this.protocolKit.getOwners();
-        const signerAddress = await this.protocolKit.getSafeProvider().getSignerAddress();
+        const safeProvider = this.protocolKit.getSafeProvider();
+        const signerAddress = await safeProvider.getSignerAddress();
+        const chainId = await safeProvider.getChainId();
+        const isPasskeySigner = await safeProvider.isPasskeySigner();
         if (!signerAddress) {
             throw new Error('There is no signer address available to sign the SafeOperation');
         }
         const addressIsOwner = owners.some((owner) => signerAddress && owner.toLowerCase() === signerAddress.toLowerCase());
-        if (!addressIsOwner) {
+        if (!addressIsOwner && !isPasskeySigner) {
             throw new Error('UserOperations can only be signed by Safe owners');
         }
         let signature;
-        if (signingMethod === protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4 ||
-            signingMethod === protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA_V3 ||
-            signingMethod === protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA) {
-            signature = await __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_signTypedData).call(this, safeOperation.data);
+        if (isPasskeySigner) {
+            const safeOpHash = (0, utils_1.calculateSafeUserOperationHash)(safeOp.data, chainId, __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f"));
+            const passkeySignature = await this.protocolKit.signHash(safeOpHash);
+            // SafeWebAuthnSharedSigner signature
+            signature = new protocol_kit_1.EthSafeSignature(SAFE_WEBAUTHN_SHARED_SIGNER_ADDRESS, passkeySignature.data, true);
         }
         else {
-            const chainId = await this.protocolKit.getSafeProvider().getChainId();
-            const safeOpHash = __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_getSafeUserOperationHash).call(this, safeOperation.data, chainId);
-            signature = await this.protocolKit.signHash(safeOpHash);
+            if (signingMethod in
+                [
+                    protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA_V4,
+                    protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA_V3,
+                    protocol_kit_1.SigningMethod.ETH_SIGN_TYPED_DATA
+                ]) {
+                signature = await (0, utils_1.signSafeOp)(safeOp.data, this.protocolKit.getSafeProvider(), __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f"));
+            }
+            else {
+                const safeOpHash = (0, utils_1.calculateSafeUserOperationHash)(safeOp.data, chainId, __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f"));
+                signature = await this.protocolKit.signHash(safeOpHash);
+            }
         }
-        const signedSafeOperation = new SafeOperation_1.default(safeOperation.toUserOperation(), {
+        const signedSafeOperation = new SafeOperation_1.default(safeOp.toUserOperation(), {
+            moduleAddress: __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f"),
             entryPoint: __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f"),
-            validUntil: safeOperation.data.validUntil,
-            validAfter: safeOperation.data.validAfter
+            validUntil: safeOp.data.validUntil,
+            validAfter: safeOp.data.validAfter
         });
-        signedSafeOperation.signatures.forEach((signature) => {
+        safeOp.signatures.forEach((signature) => {
             signedSafeOperation.addSignature(signature);
         });
         signedSafeOperation.addSignature(signature);
@@ -370,12 +456,25 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
     /**
      * Executes the relay transaction.
      *
-     * @param {EthSafeOperation} safeOperation - The SafeOperation to execute.
+     * @param {Safe4337ExecutableProps} props - The parameters for the transaction execution.
+     * @param {EthSafeOperation | SafeOperationResponse} props.executable - The SafeOperation to execute. It can be:
+     * - A response from the API (Tx Service)
+     * - An instance of EthSafeOperation
      * @return {Promise<string>} The user operation hash.
      */
-    async executeTransaction({ executable: safeOperation }) {
+    async executeTransaction({ executable }) {
+        let safeOperation;
+        if ((0, safe_core_sdk_types_1.isSafeOperationResponse)(executable)) {
+            safeOperation = __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_toSafeOperation).call(this, executable);
+        }
+        else {
+            safeOperation = executable;
+        }
         const userOperation = safeOperation.toUserOperation();
-        return __classPrivateFieldGet(this, _Safe4337Pack_instances, "m", _Safe4337Pack_sendUserOperation).call(this, userOperation);
+        return __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.SEND_USER_OPERATION, [
+            (0, utils_1.userOperationToHexValues)(userOperation),
+            __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f")
+        ]);
     }
     /**
      * Return a UserOperation based on a hash (userOpHash) returned by eth_sendUserOperation
@@ -384,8 +483,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      * @returns {UserOperation} - null in case the UserOperation is not yet included in a block, or a full UserOperation, with the addition of entryPoint, blockNumber, blockHash and transactionHash
      */
     async getUserOperationByHash(userOpHash) {
-        const userOperation = await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.GET_USER_OPERATION_BY_HASH, [userOpHash]);
-        return userOperation;
+        return __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.GET_USER_OPERATION_BY_HASH, [userOpHash]);
     }
     /**
      * Return a UserOperation receipt based on a hash (userOpHash) returned by eth_sendUserOperation
@@ -394,8 +492,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      * @returns {UserOperationReceipt} - null in case the UserOperation is not yet included in a block, or UserOperationReceipt object
      */
     async getUserOperationReceipt(userOpHash) {
-        const userOperationReceipt = await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.GET_USER_OPERATION_RECEIPT, [userOpHash]);
-        return userOperationReceipt;
+        return __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.GET_USER_OPERATION_RECEIPT, [userOpHash]);
     }
     /**
      * Returns an array of the entryPoint addresses supported by the client.
@@ -404,8 +501,7 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      * @returns {string[]} - The supported entry points.
      */
     async getSupportedEntryPoints() {
-        const supportedEntryPoints = await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.SUPPORTED_ENTRY_POINTS, []);
-        return supportedEntryPoints;
+        return __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.SUPPORTED_ENTRY_POINTS, []);
     }
     /**
      * Returns EIP-155 Chain ID.
@@ -413,60 +509,44 @@ class Safe4337Pack extends RelayKitBasePack_1.RelayKitBasePack {
      * @returns {string} - The chain id.
      */
     async getChainId() {
-        const chainId = await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.CHAIN_ID, []);
-        return chainId;
+        return __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.CHAIN_ID, []);
     }
 }
 exports.Safe4337Pack = Safe4337Pack;
-_Safe4337Pack_BUNDLER_URL = new WeakMap(), _Safe4337Pack_ENTRYPOINT_ADDRESS = new WeakMap(), _Safe4337Pack_SAFE_4337_MODULE_ADDRESS = new WeakMap(), _Safe4337Pack_bundlerClient = new WeakMap(), _Safe4337Pack_publicClient = new WeakMap(), _Safe4337Pack_paymasterOptions = new WeakMap(), _Safe4337Pack_instances = new WeakSet(), _Safe4337Pack_getSafeUserOperationHash = function _Safe4337Pack_getSafeUserOperationHash(safeUserOperation, chainId) {
-    return ethers_1.ethers.TypedDataEncoder.hash({
-        chainId,
-        verifyingContract: __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f")
-    }, constants_1.EIP712_SAFE_OPERATION_TYPE, safeUserOperation);
-}, _Safe4337Pack_sendUserOperation = 
-/**
- * Send the UserOperation to the bundler.
- *
- * @param {UserOperation} userOpWithSignature - The signed UserOperation to send to the bundler.
- * @return {Promise<string>} The hash.
- */
-async function _Safe4337Pack_sendUserOperation(userOpWithSignature) {
-    return await __classPrivateFieldGet(this, _Safe4337Pack_bundlerClient, "f").send(constants_1.RPC_4337_CALLS.SEND_USER_OPERATION, [
-        (0, utils_1.userOperationToHexValues)(userOpWithSignature),
-        __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f")
-    ]);
-}, _Safe4337Pack_signTypedData = 
-/**
- * Signs typed data.
- *
- * @param {SafeUserOperation} safeUserOperation - Safe user operation to sign.
- * @return {Promise<SafeSignature>} The SafeSignature object containing the data and the signatures.
- */
-async function _Safe4337Pack_signTypedData(safeUserOperation) {
-    const safeProvider = this.protocolKit.getSafeProvider();
-    const signer = (await safeProvider.getExternalSigner());
-    const chainId = await safeProvider.getChainId();
-    const signerAddress = await signer.getAddress();
-    const signature = await signer.signTypedData({
-        chainId,
-        verifyingContract: __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f")
-    }, constants_1.EIP712_SAFE_OPERATION_TYPE, {
-        ...safeUserOperation,
-        nonce: ethers_1.ethers.toBeHex(safeUserOperation.nonce),
-        validAfter: ethers_1.ethers.toBeHex(safeUserOperation.validAfter),
-        validUntil: ethers_1.ethers.toBeHex(safeUserOperation.validUntil),
-        maxFeePerGas: ethers_1.ethers.toBeHex(safeUserOperation.maxFeePerGas),
-        maxPriorityFeePerGas: ethers_1.ethers.toBeHex(safeUserOperation.maxPriorityFeePerGas)
+_Safe4337Pack_BUNDLER_URL = new WeakMap(), _Safe4337Pack_ENTRYPOINT_ADDRESS = new WeakMap(), _Safe4337Pack_SAFE_4337_MODULE_ADDRESS = new WeakMap(), _Safe4337Pack_bundlerClient = new WeakMap(), _Safe4337Pack_paymasterOptions = new WeakMap(), _Safe4337Pack_instances = new WeakSet(), _Safe4337Pack_toSafeOperation = function _Safe4337Pack_toSafeOperation(safeOperationResponse) {
+    const { validUntil, validAfter, userOperation } = safeOperationResponse;
+    const safeOperation = new SafeOperation_1.default({
+        sender: userOperation?.sender || '0x',
+        nonce: userOperation?.nonce?.toString() || '0',
+        initCode: userOperation?.initCode || '',
+        callData: userOperation?.callData || '',
+        callGasLimit: BigInt(userOperation?.callGasLimit || 0n),
+        verificationGasLimit: BigInt(userOperation?.verificationGasLimit || 0),
+        preVerificationGas: BigInt(userOperation?.preVerificationGas || 0),
+        maxFeePerGas: BigInt(userOperation?.maxFeePerGas || 0),
+        maxPriorityFeePerGas: BigInt(userOperation?.maxPriorityFeePerGas || 0),
+        paymasterAndData: userOperation?.paymasterData || '0x',
+        signature: userOperation?.signature || '0x'
+    }, {
+        moduleAddress: __classPrivateFieldGet(this, _Safe4337Pack_SAFE_4337_MODULE_ADDRESS, "f"),
+        entryPoint: userOperation?.entryPoint || __classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f"),
+        validAfter: validAfter ? new Date(validAfter).getTime() : undefined,
+        validUntil: validUntil ? new Date(validUntil).getTime() : undefined
     });
-    return new protocol_kit_1.EthSafeSignature(signerAddress, signature);
-}, _Safe4337Pack_getAccountNonce = 
+    if (safeOperationResponse.confirmations) {
+        safeOperationResponse.confirmations.forEach((confirmation) => {
+            safeOperation.addSignature(new protocol_kit_1.EthSafeSignature(confirmation.owner, confirmation.signature));
+        });
+    }
+    return safeOperation;
+}, _Safe4337Pack_getSafeNonceFromEntrypoint = 
 /**
  * Gets account nonce from the bundler.
  *
- * @param {string} sender - Account address for which the nonce is to be fetched.
+ * @param {string} safeAddress - Account address for which the nonce is to be fetched.
  * @returns {Promise<string>} The Promise object will resolve to the account nonce.
  */
-async function _Safe4337Pack_getAccountNonce(sender) {
+async function _Safe4337Pack_getSafeNonceFromEntrypoint(safeAddress) {
     const abi = [
         {
             inputs: [
@@ -479,8 +559,8 @@ async function _Safe4337Pack_getAccountNonce(sender) {
             type: 'function'
         }
     ];
-    const contract = new ethers_1.ethers.Contract(__classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f") || '0x', abi, __classPrivateFieldGet(this, _Safe4337Pack_publicClient, "f"));
-    const newNonce = await contract.getNonce(sender, BigInt(0));
+    const contract = new ethers_1.ethers.Contract(__classPrivateFieldGet(this, _Safe4337Pack_ENTRYPOINT_ADDRESS, "f") || '0x', abi, this.protocolKit.getSafeProvider().getExternalProvider());
+    const newNonce = await contract.getNonce(safeAddress, BigInt(0));
     return newNonce.toString();
 }, _Safe4337Pack_encodeExecuteUserOpCallData = function _Safe4337Pack_encodeExecuteUserOpCallData(transaction) {
     return constants_1.INTERFACES.encodeFunctionData('executeUserOp', [
@@ -489,9 +569,5 @@ async function _Safe4337Pack_getAccountNonce(sender) {
         transaction.data,
         transaction.operation || safe_core_sdk_types_1.OperationType.Call
     ]);
-}, _Safe4337Pack_encodeMultiSendCallData = function _Safe4337Pack_encodeMultiSendCallData(transactions) {
-    return constants_1.INTERFACES.encodeFunctionData('multiSend', [
-        (0, protocol_kit_1.encodeMultiSendData)(transactions.map((tx) => ({ ...tx, operation: tx.operation ?? safe_core_sdk_types_1.OperationType.Call })))
-    ]);
 };
 //# sourceMappingURL=Safe4337Pack.js.map