@aastar/sdk 0.14.0 → 0.14.3

package/ext/permissionless.js/packages/permissionless/accounts/safe/toSafeSmartAccount.ts

@@ -0,0 +1,1980 @@
+import {
+    type Account,
+    type Address,
+    type Assign,
+    type Chain,
+    type Client,
+    type Hex,
+    type JsonRpcAccount,
+    type LocalAccount,
+    type OneOf,
+    type SignableMessage,
+    type Transport,
+    type TypedData,
+    type TypedDataDefinition,
+    type WalletClient,
+    concat,
+    decodeFunctionData,
+    encodeAbiParameters,
+    encodeFunctionData,
+    encodePacked,
+    getAddress,
+    getContractAddress,
+    hashMessage,
+    hashTypedData,
+    hexToBigInt,
+    keccak256,
+    pad,
+    size,
+    slice,
+    toBytes,
+    toHex,
+    zeroAddress
+} from "viem"
+import {
+    type SmartAccount,
+    type SmartAccountImplementation,
+    type UserOperation,
+    type WebAuthnAccount,
+    entryPoint06Abi,
+    entryPoint07Abi,
+    entryPoint07Address,
+    toSmartAccount
+} from "viem/account-abstraction"
+import { getChainId, readContract } from "viem/actions"
+import { getAction } from "viem/utils"
+import { getAccountNonce } from "../../actions/public/getAccountNonce.js"
+import { decode7579Calls } from "../../utils/decode7579Calls.js"
+import { encode7579Calls } from "../../utils/encode7579Calls.js"
+import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed.js"
+import { getOxExports } from "../../utils/ox.js"
+import { type EthereumProvider, toOwner } from "../../utils/toOwner.js"
+import {
+    concatSignatures,
+    getWebAuthnSignature,
+    signUserOperation
+} from "./signUserOperation.js"
+
+export type SafeVersion = "1.4.1" | "1.5.0"
+
+const multiSendAbi = [
+    {
+        inputs: [
+            {
+                internalType: "bytes",
+                name: "transactions",
+                type: "bytes"
+            }
+        ],
+        name: "multiSend",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function"
+    }
+] as const
+
+const initSafe7579Abi = [
+    {
+        type: "function",
+        name: "initSafe7579",
+        inputs: [
+            {
+                name: "safe7579",
+                type: "address",
+                internalType: "address"
+            },
+            {
+                name: "executors",
+                type: "tuple[]",
+                internalType: "struct ModuleInit[]",
+                components: [
+                    {
+                        name: "module",
+                        type: "address",
+                        internalType: "address"
+                    },
+                    {
+                        name: "initData",
+                        type: "bytes",
+                        internalType: "bytes"
+                    }
+                ]
+            },
+            {
+                name: "fallbacks",
+                type: "tuple[]",
+                internalType: "struct ModuleInit[]",
+                components: [
+                    {
+                        name: "module",
+                        type: "address",
+                        internalType: "address"
+                    },
+                    {
+                        name: "initData",
+                        type: "bytes",
+                        internalType: "bytes"
+                    }
+                ]
+            },
+            {
+                name: "hooks",
+                type: "tuple[]",
+                internalType: "struct ModuleInit[]",
+                components: [
+                    {
+                        name: "module",
+                        type: "address",
+                        internalType: "address"
+                    },
+                    {
+                        name: "initData",
+                        type: "bytes",
+                        internalType: "bytes"
+                    }
+                ]
+            },
+            {
+                name: "attesters",
+                type: "address[]",
+                internalType: "address[]"
+            },
+            {
+                name: "threshold",
+                type: "uint8",
+                internalType: "uint8"
+            }
+        ],
+        outputs: [],
+        stateMutability: "nonpayable"
+    }
+] as const
+
+const preValidationSetupAbi = [
+    {
+        type: "function",
+        name: "preValidationSetup",
+        inputs: [
+            {
+                name: "initHash",
+                type: "bytes32",
+                internalType: "bytes32"
+            },
+            {
+                name: "to",
+                type: "address",
+                internalType: "address"
+            },
+            {
+                name: "preInit",
+                type: "bytes",
+                internalType: "bytes"
+            }
+        ],
+        outputs: [],
+        stateMutability: "nonpayable"
+    }
+] as const
+
+const enableModulesAbi = [
+    {
+        inputs: [
+            {
+                internalType: "address[]",
+                name: "modules",
+                type: "address[]"
+            }
+        ],
+        name: "enableModules",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+    }
+] as const
+
+const safeWebAuthnSharedSignerAbi = [
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: "uint256",
+                        name: "x",
+                        type: "uint256"
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "y",
+                        type: "uint256"
+                    },
+                    {
+                        internalType: "P256.Verifiers",
+                        name: "verifiers",
+                        type: "uint176"
+                    }
+                ],
+                internalType: "struct SafeWebAuthnSharedSigner.Signer",
+                name: "signer",
+                type: "tuple"
+            }
+        ],
+        name: "configure",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+    }
+] as const
+
+const setupAbi = [
+    {
+        inputs: [
+            {
+                internalType: "address[]",
+                name: "_owners",
+                type: "address[]"
+            },
+            {
+                internalType: "uint256",
+                name: "_threshold",
+                type: "uint256"
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address"
+            },
+            {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+            },
+            {
+                internalType: "address",
+                name: "fallbackHandler",
+                type: "address"
+            },
+            {
+                internalType: "address",
+                name: "paymentToken",
+                type: "address"
+            },
+            {
+                internalType: "uint256",
+                name: "payment",
+                type: "uint256"
+            },
+            {
+                internalType: "address payable",
+                name: "paymentReceiver",
+                type: "address"
+            }
+        ],
+        name: "setup",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+    }
+] as const
+
+const createProxyWithNonceAbi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "_singleton",
+                type: "address"
+            },
+            {
+                internalType: "bytes",
+                name: "initializer",
+                type: "bytes"
+            },
+            {
+                internalType: "uint256",
+                name: "saltNonce",
+                type: "uint256"
+            }
+        ],
+        name: "createProxyWithNonce",
+        outputs: [
+            {
+                internalType: "contract SafeProxy",
+                name: "proxy",
+                type: "address"
+            }
+        ],
+        stateMutability: "nonpayable",
+        type: "function"
+    }
+] as const
+
+const setupSafeAbi = [
+    {
+        type: "function",
+        name: "setupSafe",
+        inputs: [
+            {
+                name: "initData",
+                type: "tuple",
+                internalType: "struct Safe7579Launchpad.InitData",
+                components: [
+                    {
+                        name: "singleton",
+                        type: "address",
+                        internalType: "address"
+                    },
+                    {
+                        name: "owners",
+                        type: "address[]",
+                        internalType: "address[]"
+                    },
+                    {
+                        name: "threshold",
+                        type: "uint256",
+                        internalType: "uint256"
+                    },
+                    {
+                        name: "setupTo",
+                        type: "address",
+                        internalType: "address"
+                    },
+                    {
+                        name: "setupData",
+                        type: "bytes",
+                        internalType: "bytes"
+                    },
+                    {
+                        name: "safe7579",
+                        type: "address",
+                        internalType: "contract ISafe7579"
+                    },
+                    {
+                        name: "validators",
+                        type: "tuple[]",
+                        internalType: "struct ModuleInit[]",
+                        components: [
+                            {
+                                name: "module",
+                                type: "address",
+                                internalType: "address"
+                            },
+                            {
+                                name: "initData",
+                                type: "bytes",
+                                internalType: "bytes"
+                            }
+                        ]
+                    },
+                    {
+                        name: "callData",
+                        type: "bytes",
+                        internalType: "bytes"
+                    }
+                ]
+            }
+        ],
+        outputs: [],
+        stateMutability: "nonpayable"
+    }
+] as const
+
+const executeUserOpWithErrorStringAbi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "to",
+                type: "address"
+            },
+            {
+                internalType: "uint256",
+                name: "value",
+                type: "uint256"
+            },
+            {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes"
+            },
+            {
+                internalType: "uint8",
+                name: "operation",
+                type: "uint8"
+            }
+        ],
+        name: "executeUserOpWithErrorString",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+    }
+] as const
+
+export const EIP712_SAFE_OPERATION_TYPE_V06 = {
+    SafeOp: [
+        { type: "address", name: "safe" },
+        { type: "uint256", name: "nonce" },
+        { type: "bytes", name: "initCode" },
+        { type: "bytes", name: "callData" },
+        { type: "uint256", name: "callGasLimit" },
+        { type: "uint256", name: "verificationGasLimit" },
+        { type: "uint256", name: "preVerificationGas" },
+        { type: "uint256", name: "maxFeePerGas" },
+        { type: "uint256", name: "maxPriorityFeePerGas" },
+        { type: "bytes", name: "paymasterAndData" },
+        { type: "uint48", name: "validAfter" },
+        { type: "uint48", name: "validUntil" },
+        { type: "address", name: "entryPoint" }
+    ]
+}
+
+export const EIP712_SAFE_OPERATION_TYPE_V07 = {
+    SafeOp: [
+        { type: "address", name: "safe" },
+        { type: "uint256", name: "nonce" },
+        { type: "bytes", name: "initCode" },
+        { type: "bytes", name: "callData" },
+        { type: "uint128", name: "verificationGasLimit" },
+        { type: "uint128", name: "callGasLimit" },
+        { type: "uint256", name: "preVerificationGas" },
+        { type: "uint128", name: "maxPriorityFeePerGas" },
+        { type: "uint128", name: "maxFeePerGas" },
+        { type: "bytes", name: "paymasterAndData" },
+        { type: "uint48", name: "validAfter" },
+        { type: "uint48", name: "validUntil" },
+        { type: "address", name: "entryPoint" }
+    ]
+}
+
+const SAFE_VERSION_TO_ADDRESSES_MAP: {
+    [key in SafeVersion]: {
+        "0.6"?: {
+            SAFE_MODULE_SETUP_ADDRESS: Address
+            SAFE_4337_MODULE_ADDRESS: Address
+            SAFE_PROXY_FACTORY_ADDRESS: Address
+            SAFE_SINGLETON_ADDRESS: Address
+            MULTI_SEND_ADDRESS: Address
+            MULTI_SEND_CALL_ONLY_ADDRESS: Address
+            WEB_AUTHN_SHARED_SIGNER_ADDRESS?: never
+            SAFE_P256_VERIFIER_ADDRESS?: never
+        }
+        "0.7": {
+            SAFE_MODULE_SETUP_ADDRESS: Address
+            SAFE_4337_MODULE_ADDRESS: Address
+            SAFE_PROXY_FACTORY_ADDRESS: Address
+            SAFE_SINGLETON_ADDRESS: Address
+            MULTI_SEND_ADDRESS: Address
+            MULTI_SEND_CALL_ONLY_ADDRESS: Address
+            WEB_AUTHN_SHARED_SIGNER_ADDRESS: Address
+            SAFE_P256_VERIFIER_ADDRESS: Address
+        }
+    }
+} = {
+    "1.4.1": {
+        "0.6": {
+            SAFE_MODULE_SETUP_ADDRESS:
+                "0x8EcD4ec46D4D2a6B64fE960B3D64e8B94B2234eb",
+            SAFE_4337_MODULE_ADDRESS:
+                "0xa581c4A4DB7175302464fF3C06380BC3270b4037",
+            SAFE_PROXY_FACTORY_ADDRESS:
+                "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67",
+            SAFE_SINGLETON_ADDRESS:
+                "0x41675C099F32341bf84BFc5382aF534df5C7461a",
+            MULTI_SEND_ADDRESS: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
+            MULTI_SEND_CALL_ONLY_ADDRESS:
+                "0x9641d764fc13c8B624c04430C7356C1C7C8102e2"
+        },
+        "0.7": {
+            SAFE_MODULE_SETUP_ADDRESS:
+                "0x2dd68b007B46fBe91B9A7c3EDa5A7a1063cB5b47",
+            SAFE_4337_MODULE_ADDRESS:
+                "0x75cf11467937ce3F2f357CE24ffc3DBF8fD5c226",
+            SAFE_PROXY_FACTORY_ADDRESS:
+                "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67",
+            SAFE_SINGLETON_ADDRESS:
+                "0x41675C099F32341bf84BFc5382aF534df5C7461a",
+            MULTI_SEND_ADDRESS: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
+            MULTI_SEND_CALL_ONLY_ADDRESS:
+                "0x9641d764fc13c8B624c04430C7356C1C7C8102e2",
+            WEB_AUTHN_SHARED_SIGNER_ADDRESS:
+                "0x94a4F6affBd8975951142c3999aEAB7ecee555c2",
+            SAFE_P256_VERIFIER_ADDRESS:
+                "0xA86e0054C51E4894D88762a017ECc5E5235f5DBA"
+        }
+    },
+    "1.5.0": {
+        "0.7": {
+            SAFE_MODULE_SETUP_ADDRESS:
+                "0x2dd68b007B46fBe91B9A7c3EDa5A7a1063cB5b47",
+            SAFE_4337_MODULE_ADDRESS:
+                "0x75cf11467937ce3F2f357CE24ffc3DBF8fD5c226",
+            SAFE_PROXY_FACTORY_ADDRESS:
+                "0x14F2982D601c9458F93bd70B218933A6f8165e7b",
+            SAFE_SINGLETON_ADDRESS:
+                "0xFf51A5898e281Db6DfC7855790607438dF2ca44b",
+            MULTI_SEND_ADDRESS: "0x218543288004CD07832472D464648173c77D7eB7",
+            MULTI_SEND_CALL_ONLY_ADDRESS:
+                "0xA83c336B20401Af773B6219BA5027174338D1836",
+            WEB_AUTHN_SHARED_SIGNER_ADDRESS:
+                "0x94a4F6affBd8975951142c3999aEAB7ecee555c2",
+            SAFE_P256_VERIFIER_ADDRESS:
+                "0xA86e0054C51E4894D88762a017ECc5E5235f5DBA"
+        }
+    }
+}
+
+const adjustVInSignature = (
+    signingMethod: "eth_sign" | "eth_signTypedData",
+    signature: string
+): Hex => {
+    const ETHEREUM_V_VALUES = [0, 1, 27, 28]
+    const MIN_VALID_V_VALUE_FOR_SAFE_ECDSA = 27
+    let signatureV = Number.parseInt(signature.slice(-2), 16)
+    if (!ETHEREUM_V_VALUES.includes(signatureV)) {
+        throw new Error("Invalid signature")
+    }
+    if (signingMethod === "eth_sign") {
+        if (signatureV < MIN_VALID_V_VALUE_FOR_SAFE_ECDSA) {
+            signatureV += MIN_VALID_V_VALUE_FOR_SAFE_ECDSA
+        }
+        signatureV += 4
+    }
+    if (signingMethod === "eth_signTypedData") {
+        if (signatureV < MIN_VALID_V_VALUE_FOR_SAFE_ECDSA) {
+            signatureV += MIN_VALID_V_VALUE_FOR_SAFE_ECDSA
+        }
+    }
+    return (signature.slice(0, -2) + signatureV.toString(16)) as Hex
+}
+
+const generateSafeMessageMessage = <
+    const TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData
+>(
+    message: SignableMessage | TypedDataDefinition<TTypedData, TPrimaryType>
+): Hex => {
+    const signableMessage = message as SignableMessage
+
+    if (typeof signableMessage === "string" || signableMessage.raw) {
+        return hashMessage(signableMessage)
+    }
+
+    return hashTypedData(
+        message as TypedDataDefinition<TTypedData, TPrimaryType>
+    )
+}
+
+const encodeInternalTransaction = (tx: {
+    to: Address
+    data: Address
+    value: bigint
+    operation: 0 | 1
+}): string => {
+    const encoded = encodePacked(
+        // uint8 = 1 byte for operation
+        // address = 20 bytes for to address
+        // uint256 = 32 bytes for value
+        // uint256 = 32 bytes for data length
+        // bytes = dynamic length for data
+        ["uint8", "address", "uint256", "uint256", "bytes"],
+        [
+            tx.operation,
+            tx.to,
+            tx.value,
+            BigInt(tx.data.slice(2).length / 2),
+            tx.data
+        ]
+    )
+    return encoded.slice(2)
+}
+
+const encodeMultiSend = (
+    txs: {
+        to: Address
+        data: Address
+        value: bigint
+        operation: 0 | 1
+    }[]
+): Hex => {
+    const data: Hex = `0x${txs
+        .map((tx) => encodeInternalTransaction(tx))
+        .join("")}`
+
+    return encodeFunctionData({
+        abi: multiSendAbi,
+        functionName: "multiSend",
+        args: [data]
+    })
+}
+
+const get7579LaunchPadInitData = ({
+    safe4337ModuleAddress,
+    safeSingletonAddress,
+    erc7579LaunchpadAddress,
+    safeWebAuthnSharedSignerAddress,
+    owners,
+    validators,
+    executors,
+    fallbacks,
+    hooks,
+    attesters,
+    threshold,
+    attestersThreshold
+}: {
+    safe4337ModuleAddress: Address
+    safeSingletonAddress: Address
+    erc7579LaunchpadAddress: Address
+    safeWebAuthnSharedSignerAddress?: Address
+    owners: OwnersArray<readonly (RegularOwner | WebAuthnAccount)[]>
+    executors: {
+        address: Address
+        context: Address
+    }[]
+    validators: { address: Address; context: Address }[]
+    fallbacks: { address: Address; context: Address }[]
+    hooks: { address: Address; context: Address }[]
+    attesters: Address[]
+    threshold: bigint
+    attestersThreshold: number
+}) => {
+    const ownerAddresses = owners.map((owner) => {
+        if ("type" in owner && owner.type === "webAuthn") {
+            if (!safeWebAuthnSharedSignerAddress) {
+                throw new Error("safeWebAuthnSharedSignerAddress not defined")
+            }
+            return safeWebAuthnSharedSignerAddress
+        }
+
+        if ("address" in owner && owner.address) {
+            return owner.address
+        }
+
+        throw new Error("Incorrect owner found")
+    })
+
+    const initData = {
+        singleton: safeSingletonAddress,
+        owners: ownerAddresses,
+        threshold: threshold,
+        setupTo: erc7579LaunchpadAddress,
+        setupData: encodeFunctionData({
+            abi: initSafe7579Abi,
+            functionName: "initSafe7579",
+            args: [
+                safe4337ModuleAddress, // SAFE_7579_ADDRESS,
+                executors.map((executor) => ({
+                    module: executor.address,
+                    initData: executor.context
+                })),
+                fallbacks.map((fallback) => ({
+                    module: fallback.address,
+                    initData: fallback.context
+                })),
+                hooks.map((hook) => ({
+                    module: hook.address,
+                    initData: hook.context
+                })),
+                attesters.sort((left, right) =>
+                    left.toLowerCase().localeCompare(right.toLowerCase())
+                ),
+                attestersThreshold
+            ]
+        }),
+        safe7579: safe4337ModuleAddress,
+        validators: validators
+    }
+
+    return initData
+}
+
+export const isWebAuthnAccount = (
+    owner: RegularOwner | WebAuthnAccount
+): owner is WebAuthnAccount => {
+    return "type" in owner && owner.type === "webAuthn"
+}
+
+const getInitializerCode = async ({
+    owners,
+    threshold,
+    safeModuleSetupAddress,
+    safe4337ModuleAddress,
+    safeWebAuthnSharedSignerAddress,
+    safeP256VerifierAddress,
+    multiSendAddress,
+    safeSingletonAddress,
+    erc7579LaunchpadAddress,
+    setupTransactions = [],
+    safeModules = [],
+    validators = [],
+    executors = [],
+    fallbacks = [],
+    hooks = [],
+    attesters = [],
+    attestersThreshold = 0,
+    paymentToken = zeroAddress,
+    payment = BigInt(0),
+    paymentReceiver = zeroAddress
+}: {
+    owners: OwnersArray<readonly (RegularOwner | WebAuthnAccount)[]>
+    threshold: bigint
+    safeSingletonAddress: Address
+    safeModuleSetupAddress: Address
+    safe4337ModuleAddress: Address
+    safeWebAuthnSharedSignerAddress?: Address
+    safeP256VerifierAddress?: Address
+    multiSendAddress: Address
+    erc7579LaunchpadAddress?: Address
+    setupTransactions?: {
+        to: Address
+        data: Address
+        value: bigint
+    }[]
+    safeModules?: Address[]
+    validators?: { address: Address; context: Address }[]
+    executors?: {
+        address: Address
+        context: Address
+    }[]
+    fallbacks?: { address: Address; context: Address }[]
+    hooks?: { address: Address; context: Address }[]
+    attesters?: Address[]
+    attestersThreshold?: number
+    paymentToken?: Address
+    payment?: bigint
+    paymentReceiver?: Address
+}) => {
+    if (erc7579LaunchpadAddress) {
+        const initData = get7579LaunchPadInitData({
+            safe4337ModuleAddress,
+            safeSingletonAddress,
+            safeWebAuthnSharedSignerAddress,
+            erc7579LaunchpadAddress,
+            owners,
+            validators,
+            executors,
+            fallbacks,
+            threshold,
+            hooks,
+            attesters,
+            attestersThreshold
+        })
+
+        const initHash = keccak256(
+            encodeAbiParameters(
+                [
+                    {
+                        internalType: "address",
+                        name: "singleton",
+                        type: "address"
+                    },
+                    {
+                        internalType: "address[]",
+                        name: "owners",
+                        type: "address[]"
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "threshold",
+                        type: "uint256"
+                    },
+                    {
+                        internalType: "address",
+                        name: "setupTo",
+                        type: "address"
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "setupData",
+                        type: "bytes"
+                    },
+                    {
+                        internalType: "contract ISafe7579",
+                        name: "safe7579",
+                        type: "address"
+                    },
+                    {
+                        internalType: "struct ModuleInit[]",
+                        name: "validators",
+                        type: "tuple[]",
+                        components: [
+                            {
+                                internalType: "address",
+                                name: "module",
+                                type: "address"
+                            },
+                            {
+                                internalType: "bytes",
+                                name: "initData",
+                                type: "bytes"
+                            }
+                        ]
+                    }
+                ],
+                [
+                    initData.singleton,
+                    initData.owners,
+                    initData.threshold,
+                    initData.setupTo,
+                    initData.setupData,
+                    initData.safe7579,
+                    initData.validators.map((validator) => ({
+                        module: validator.address,
+                        initData: validator.context
+                    }))
+                ]
+            )
+        )
+
+        return encodeFunctionData({
+            abi: preValidationSetupAbi,
+            functionName: "preValidationSetup",
+            args: [initHash, zeroAddress, "0x"]
+        })
+    }
+
+    const webAuthnOwner = owners.reduce<WebAuthnAccount | undefined>(
+        (acc, owner) => {
+            if (isWebAuthnAccount(owner)) {
+                return owner
+            }
+            return acc
+        },
+        undefined
+    )
+
+    const ownerAddresses = owners.map((owner) => {
+        if (isWebAuthnAccount(owner)) {
+            if (!safeWebAuthnSharedSignerAddress) {
+                throw new Error("safeWebAuthnSharedSignerAddress not defined")
+            }
+            return safeWebAuthnSharedSignerAddress
+        }
+
+        if ("address" in owner && owner.address) {
+            return owner.address
+        }
+
+        throw new Error("Incorrect owner found")
+    })
+
+    const multiCalls = [
+        {
+            to: safeModuleSetupAddress,
+            data: encodeFunctionData({
+                abi: enableModulesAbi,
+                functionName: "enableModules",
+                args: [[safe4337ModuleAddress, ...safeModules]]
+            }),
+            value: BigInt(0),
+            operation: 1 as 0 | 1
+        }
+    ]
+
+    if (
+        webAuthnOwner &&
+        safeWebAuthnSharedSignerAddress &&
+        safeP256VerifierAddress
+    ) {
+        const { PublicKey } = await getOxExports()
+        const parsedPublicKey = PublicKey.fromHex(webAuthnOwner.publicKey)
+
+        multiCalls.push({
+            to: safeWebAuthnSharedSignerAddress,
+            data: encodeFunctionData({
+                abi: safeWebAuthnSharedSignerAbi,
+                functionName: "configure",
+                args: [
+                    {
+                        x: parsedPublicKey.x,
+                        y: parsedPublicKey.y,
+                        verifiers: BigInt(safeP256VerifierAddress)
+                    }
+                ]
+            }),
+            value: BigInt(0),
+            operation: 1 as 0 | 1
+        })
+    }
+
+    for (const tx of setupTransactions) {
+        multiCalls.push({
+            ...tx,
+            operation: 0 as 0 | 1
+        })
+    }
+
+    const multiSendCallData = encodeMultiSend(multiCalls)
+
+    return encodeFunctionData({
+        abi: setupAbi,
+        functionName: "setup",
+        args: [
+            ownerAddresses,
+            threshold,
+            multiSendAddress,
+            multiSendCallData,
+            safe4337ModuleAddress,
+            paymentToken,
+            payment,
+            paymentReceiver
+        ]
+    })
+}
+
+export function getPaymasterAndData(unpackedUserOperation: UserOperation) {
+    return unpackedUserOperation.paymaster
+        ? concat([
+              unpackedUserOperation.paymaster,
+              pad(
+                  toHex(
+                      unpackedUserOperation.paymasterVerificationGasLimit ||
+                          BigInt(0)
+                  ),
+                  {
+                      size: 16
+                  }
+              ),
+              pad(
+                  toHex(
+                      unpackedUserOperation.paymasterPostOpGasLimit || BigInt(0)
+                  ),
+                  {
+                      size: 16
+                  }
+              ),
+              unpackedUserOperation.paymasterData || ("0x" as Hex)
+          ])
+        : "0x"
+}
+
+const getAccountInitCode = async ({
+    owners,
+    threshold,
+    safeModuleSetupAddress,
+    safe4337ModuleAddress,
+    safeSingletonAddress,
+    erc7579LaunchpadAddress,
+    safeWebAuthnSharedSignerAddress,
+    safeP256VerifierAddress,
+    multiSendAddress,
+    paymentToken,
+    payment,
+    paymentReceiver,
+    saltNonce = BigInt(0),
+    setupTransactions = [],
+    safeModules = [],
+    validators = [],
+    executors = [],
+    fallbacks = [],
+    hooks = [],
+    attesters = [],
+    attestersThreshold = 0
+}: {
+    owners: OwnersArray<readonly (RegularOwner | WebAuthnAccount)[]>
+    threshold: bigint
+    safeModuleSetupAddress: Address
+    safe4337ModuleAddress: Address
+    safeSingletonAddress: Address
+    multiSendAddress: Address
+    safeWebAuthnSharedSignerAddress?: Address
+    safeP256VerifierAddress?: Address
+    erc7579LaunchpadAddress?: Address
+    saltNonce?: bigint
+    setupTransactions?: {
+        to: Address
+        data: Address
+        value: bigint
+    }[]
+    safeModules?: Address[]
+    validators?: { address: Address; context: Address }[]
+    executors?: {
+        address: Address
+        context: Address
+    }[]
+    fallbacks?: { address: Address; context: Address }[]
+    hooks?: { address: Address; context: Address }[]
+    attesters?: Address[]
+    attestersThreshold?: number
+    paymentToken?: Address
+    payment?: bigint
+    paymentReceiver?: Address
+}): Promise<Hex> => {
+    const initializer = await getInitializerCode({
+        owners,
+        threshold,
+        safeModuleSetupAddress,
+        safeWebAuthnSharedSignerAddress,
+        safeP256VerifierAddress,
+        safe4337ModuleAddress,
+        multiSendAddress,
+        setupTransactions,
+        safeSingletonAddress,
+        safeModules,
+        erc7579LaunchpadAddress,
+        validators,
+        executors,
+        fallbacks,
+        hooks,
+        attesters,
+        attestersThreshold,
+        paymentToken,
+        payment,
+        paymentReceiver
+    })
+
+    const initCodeCallData = encodeFunctionData({
+        abi: createProxyWithNonceAbi,
+        functionName: "createProxyWithNonce",
+        args: [
+            erc7579LaunchpadAddress ?? safeSingletonAddress,
+            initializer,
+            saltNonce
+        ]
+    })
+
+    return initCodeCallData
+}
+
+export const getDefaultAddresses = (
+    safeVersion: SafeVersion,
+    entryPointVersion: "0.6" | "0.7",
+    {
+        addModuleLibAddress: _addModuleLibAddress,
+        safeModuleSetupAddress: _safeModuleSetupAddress,
+        safe4337ModuleAddress: _safe4337ModuleAddress,
+        safeProxyFactoryAddress: _safeProxyFactoryAddress,
+        safeSingletonAddress: _safeSingletonAddress,
+        multiSendAddress: _multiSendAddress,
+        multiSendCallOnlyAddress: _multiSendCallOnlyAddress,
+        safeWebAuthnSharedSignerAddress: _safeWebAuthnSharedSignerAddress,
+        safeP256VerifierAddress: _safeP256VerifierAddress
+    }: {
+        addModuleLibAddress?: Address
+        safeModuleSetupAddress?: Address
+        safe4337ModuleAddress?: Address
+        safeProxyFactoryAddress?: Address
+        safeSingletonAddress?: Address
+        multiSendAddress?: Address
+        multiSendCallOnlyAddress?: Address
+        safeWebAuthnSharedSignerAddress?: Address
+        safeP256VerifierAddress?: Address
+    }
+) => {
+    const versionAddresses =
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion][entryPointVersion]
+
+    if (!versionAddresses) {
+        throw new Error(
+            `Safe version ${safeVersion} does not support EntryPoint version ${entryPointVersion}`
+        )
+    }
+
+    const safeModuleSetupAddress =
+        _safeModuleSetupAddress ??
+        _addModuleLibAddress ??
+        versionAddresses.SAFE_MODULE_SETUP_ADDRESS
+    const safe4337ModuleAddress =
+        _safe4337ModuleAddress ?? versionAddresses.SAFE_4337_MODULE_ADDRESS
+    const safeProxyFactoryAddress =
+        _safeProxyFactoryAddress ?? versionAddresses.SAFE_PROXY_FACTORY_ADDRESS
+    const safeSingletonAddress =
+        _safeSingletonAddress ?? versionAddresses.SAFE_SINGLETON_ADDRESS
+    const multiSendAddress =
+        _multiSendAddress ?? versionAddresses.MULTI_SEND_ADDRESS
+
+    const multiSendCallOnlyAddress =
+        _multiSendCallOnlyAddress ??
+        versionAddresses.MULTI_SEND_CALL_ONLY_ADDRESS
+
+    const safeWebAuthnSharedSignerAddress =
+        _safeWebAuthnSharedSignerAddress ??
+        versionAddresses.WEB_AUTHN_SHARED_SIGNER_ADDRESS
+    const safeP256VerifierAddress =
+        _safeP256VerifierAddress ?? versionAddresses.SAFE_P256_VERIFIER_ADDRESS
+
+    return {
+        safeModuleSetupAddress,
+        safe4337ModuleAddress,
+        safeProxyFactoryAddress,
+        safeSingletonAddress,
+        multiSendAddress,
+        multiSendCallOnlyAddress,
+        safeWebAuthnSharedSignerAddress,
+        safeP256VerifierAddress
+    }
+}
+
+type GetErc7579Params<TErc7579 extends Address | undefined> =
+    TErc7579 extends undefined
+        ? {
+              safeModuleSetupAddress?: Address
+              multiSendAddress?: Address
+              multiSendCallOnlyAddress?: Address
+              // @deprecated This field is deprecated. It is recommended to make any setup transactions in the userOperation's calldata.
+              setupTransactions?: {
+                  to: Address
+                  data: Address
+                  value: bigint
+              }[]
+              safeModules?: Address[]
+          }
+        : {
+              validators?: { address: Address; context: Address }[]
+              executors?: {
+                  address: Address
+                  context: Address
+              }[]
+              fallbacks?: { address: Address; context: Address }[]
+              hooks?: { address: Address; context: Address }[]
+              attesters?: Address[]
+              attestersThreshold?: number
+          }
+
+type RegularOwner =
+    | Account
+    | WalletClient<Transport, Chain | undefined, Account>
+    | EthereumProvider
+
+type ValidateAtMostOneWebAuthn<
+    T extends readonly unknown[],
+    SeenWebAuthn extends boolean = false
+> = T extends readonly []
+    ? true
+    : T extends readonly [infer H, ...infer Rest]
+      ? H extends WebAuthnAccount
+          ? SeenWebAuthn extends true
+              ? false
+              : ValidateAtMostOneWebAuthn<Rest, true>
+          : H extends RegularOwner
+            ? ValidateAtMostOneWebAuthn<Rest, SeenWebAuthn>
+            : false
+      : true
+
+type OwnersArray<T extends readonly (RegularOwner | WebAuthnAccount)[]> =
+    ValidateAtMostOneWebAuthn<T> extends true ? T : never
+
+export type ToSafeSmartAccountParameters<
+    entryPointVersion extends "0.6" | "0.7",
+    TErc7579 extends Address | undefined
+> = {
+    client: Client<
+        Transport,
+        Chain | undefined,
+        JsonRpcAccount | LocalAccount | undefined
+    >
+    owners: OwnersArray<readonly (RegularOwner | WebAuthnAccount)[]>
+    threshold?: bigint
+    version: SafeVersion
+    entryPoint?: {
+        address: Address
+        version: entryPointVersion
+    }
+    safe4337ModuleAddress?: Address
+    erc7579LaunchpadAddress?: TErc7579
+    safeProxyFactoryAddress?: Address
+    safeSingletonAddress?: Address
+    safeWebAuthnSharedSignerAddress?: Address
+    safeP256VerifierAddress?: Address
+    address?: Address
+    saltNonce?: bigint
+    validUntil?: number
+    validAfter?: number
+    nonceKey?: bigint
+    paymentToken?: Address
+    payment?: bigint
+    paymentReceiver?: Address
+    onchainIdentifier?: Hex
+} & GetErc7579Params<TErc7579>
+
+function isErc7579Args<entryPointVersion extends "0.6" | "0.7" = "0.7">(
+    args: ToSafeSmartAccountParameters<entryPointVersion, Address | undefined>
+): args is ToSafeSmartAccountParameters<entryPointVersion, Address> {
+    return args.erc7579LaunchpadAddress !== undefined
+}
+
+const proxyCreationCodeAbi = [
+    {
+        inputs: [],
+        name: "proxyCreationCode",
+        outputs: [
+            {
+                internalType: "bytes",
+                name: "",
+                type: "bytes"
+            }
+        ],
+        stateMutability: "pure",
+        type: "function"
+    }
+] as const
+
+const getAccountAddress = async ({
+    client,
+    owners,
+    threshold,
+    safeModuleSetupAddress,
+    safe4337ModuleAddress,
+    safeProxyFactoryAddress,
+    safeSingletonAddress,
+    multiSendAddress,
+    safeWebAuthnSharedSignerAddress,
+    safeP256VerifierAddress,
+    erc7579LaunchpadAddress,
+    paymentToken,
+    payment,
+    paymentReceiver,
+    setupTransactions = [],
+    safeModules = [],
+    saltNonce = BigInt(0),
+    validators = [],
+    executors = [],
+    fallbacks = [],
+    hooks = [],
+    attesters = [],
+    attestersThreshold = 0
+}: {
+    client: Client
+    owners: OwnersArray<readonly (RegularOwner | WebAuthnAccount)[]>
+    threshold: bigint
+    safeModuleSetupAddress: Address
+    safe4337ModuleAddress: Address
+    safeProxyFactoryAddress: Address
+    safeSingletonAddress: Address
+    safeWebAuthnSharedSignerAddress?: Address
+    safeP256VerifierAddress?: Address
+    multiSendAddress: Address
+    setupTransactions: {
+        to: Address
+        data: Address
+        value: bigint
+    }[]
+    paymentToken?: Address
+    payment?: bigint
+    paymentReceiver?: Address
+    safeModules?: Address[]
+    saltNonce?: bigint
+    erc7579LaunchpadAddress?: Address
+    validators?: { address: Address; context: Address }[]
+    executors?: {
+        address: Address
+        context: Address
+    }[]
+    fallbacks?: { address: Address; context: Address }[]
+    hooks?: { address: Address; context: Address }[]
+    attesters?: Address[]
+    attestersThreshold?: number
+}): Promise<Address> => {
+    const proxyCreationCode = await readContract(client, {
+        abi: proxyCreationCodeAbi,
+        address: safeProxyFactoryAddress,
+        functionName: "proxyCreationCode"
+    })
+
+    const initializer = await getInitializerCode({
+        owners,
+        threshold,
+        safeModuleSetupAddress,
+        safe4337ModuleAddress,
+        safeWebAuthnSharedSignerAddress,
+        safeP256VerifierAddress,
+        multiSendAddress,
+        setupTransactions,
+        safeSingletonAddress,
+        safeModules,
+        erc7579LaunchpadAddress,
+        validators,
+        executors,
+        fallbacks,
+        hooks,
+        attesters,
+        attestersThreshold,
+        paymentToken,
+        payment,
+        paymentReceiver
+    })
+
+    const deploymentCode = encodePacked(
+        ["bytes", "uint256"],
+        [
+            proxyCreationCode,
+            hexToBigInt(erc7579LaunchpadAddress ?? safeSingletonAddress)
+        ]
+    )
+
+    const salt = keccak256(
+        encodePacked(
+            ["bytes32", "uint256"],
+            [keccak256(encodePacked(["bytes"], [initializer])), saltNonce]
+        )
+    )
+
+    return getContractAddress({
+        from: safeProxyFactoryAddress,
+        salt,
+        bytecode: deploymentCode,
+        opcode: "CREATE2"
+    })
+}
+
+export type SafeSmartAccountImplementation<
+    entryPointVersion extends "0.6" | "0.7" = "0.7"
+> = Assign<
+    SmartAccountImplementation<
+        entryPointVersion extends "0.6"
+            ? typeof entryPoint06Abi
+            : typeof entryPoint07Abi,
+        entryPointVersion
+        // {
+        //     // entryPoint === ENTRYPOINT_ADDRESS_V06 ? "0.2.2" : "0.3.0-beta"
+        //     abi: entryPointVersion extends "0.6" ? typeof BiconomyAbi
+        //     factory: { abi: typeof FactoryAbi; address: Address }
+        // }
+    >,
+    { sign: NonNullable<SmartAccountImplementation["sign"]> }
+>
+
+export type ToSafeSmartAccountReturnType<
+    entryPointVersion extends "0.6" | "0.7" = "0.7"
+> = SmartAccount<SafeSmartAccountImplementation<entryPointVersion>>
+
+/**
+ * @description Creates an Simple Account from a private key.
+ *
+ * @returns A Private Key Simple Account.
+ */
+export async function toSafeSmartAccount<
+    entryPointVersion extends "0.6" | "0.7",
+    TErc7579 extends Address | undefined
+>(
+    parameters: ToSafeSmartAccountParameters<entryPointVersion, TErc7579>
+): Promise<ToSafeSmartAccountReturnType<entryPointVersion>> {
+    const {
+        client,
+        owners: _owners,
+        address,
+        threshold = BigInt(_owners.length),
+        version,
+        safe4337ModuleAddress: _safe4337ModuleAddress,
+        safeProxyFactoryAddress: _safeProxyFactoryAddress,
+        safeSingletonAddress: _safeSingletonAddress,
+        erc7579LaunchpadAddress,
+        saltNonce = BigInt(0),
+        validUntil = 0,
+        validAfter = 0,
+        nonceKey,
+        paymentToken,
+        payment,
+        paymentReceiver,
+        onchainIdentifier
+    } = parameters
+
+    const owners = await Promise.all(
+        _owners.map(async (owner) => {
+            if ("account" in owner) {
+                return owner.account
+            }
+
+            if ("request" in owner) {
+                return toOwner({
+                    owner: owner as EthereumProvider
+                })
+            }
+
+            return owner
+        })
+    )
+
+    const localOwners = await Promise.all(
+        _owners
+            .filter((owner) => {
+                if ("type" in owner && owner.type === "local") {
+                    return true
+                }
+
+                if ("request" in owner) {
+                    return true
+                }
+
+                if ("account" in owner) {
+                    // walletClient
+                    return true
+                }
+
+                if (isWebAuthnAccount(owner)) {
+                    return true
+                }
+
+                return false
+            })
+            .map((owner) => {
+                if (isWebAuthnAccount(owner)) {
+                    return owner
+                }
+
+                return toOwner({
+                    owner: owner as OneOf<
+                        | LocalAccount
+                        | EthereumProvider
+                        | WalletClient<Transport, Chain | undefined, Account>
+                    >
+                })
+            })
+    )
+
+    const entryPoint = {
+        address: parameters.entryPoint?.address ?? entryPoint07Address,
+        abi:
+            (parameters.entryPoint?.version ?? "0.7") === "0.6"
+                ? entryPoint06Abi
+                : entryPoint07Abi,
+        version: parameters.entryPoint?.version ?? "0.7"
+    } as const
+
+    let _safeModuleSetupAddress: Address | undefined = undefined
+    let _multiSendAddress: Address | undefined = undefined
+    let _multiSendCallOnlyAddress: Address | undefined = undefined
+    let safeModules: Address[] | undefined = undefined
+    let setupTransactions: {
+        to: Address
+        data: Hex
+        value: bigint
+    }[] = []
+    let validators: { address: Address; context: Address }[] = []
+    let executors: { address: Address; context: Address }[] = []
+    let fallbacks: { address: Address; context: Address }[] = []
+    let hooks: { address: Address; context: Address }[] = []
+    let attesters: Address[] = []
+    let attestersThreshold = 0
+
+    if (!isErc7579Args(parameters)) {
+        _safeModuleSetupAddress = parameters.safeModuleSetupAddress
+        _multiSendAddress = parameters.multiSendAddress
+        _multiSendCallOnlyAddress = parameters.multiSendCallOnlyAddress
+        safeModules = parameters.safeModules
+        setupTransactions = parameters.setupTransactions ?? []
+    }
+
+    if (isErc7579Args(parameters)) {
+        validators = parameters.validators ?? []
+        executors = parameters.executors ?? []
+        fallbacks = parameters.fallbacks ?? []
+        hooks = parameters.hooks ?? []
+        attesters = parameters.attesters ?? []
+        attestersThreshold = parameters.attestersThreshold ?? 0
+    }
+
+    const {
+        safeModuleSetupAddress,
+        safe4337ModuleAddress,
+        safeProxyFactoryAddress,
+        safeSingletonAddress,
+        multiSendAddress,
+        multiSendCallOnlyAddress,
+        safeWebAuthnSharedSignerAddress,
+        safeP256VerifierAddress
+    } = getDefaultAddresses(version, entryPoint.version, {
+        safeModuleSetupAddress: _safeModuleSetupAddress,
+        safe4337ModuleAddress: _safe4337ModuleAddress,
+        safeProxyFactoryAddress: _safeProxyFactoryAddress,
+        safeSingletonAddress: _safeSingletonAddress,
+        multiSendAddress: _multiSendAddress,
+        multiSendCallOnlyAddress: _multiSendCallOnlyAddress,
+        safeWebAuthnSharedSignerAddress:
+            parameters.safeWebAuthnSharedSignerAddress,
+        safeP256VerifierAddress: parameters.safeP256VerifierAddress
+    })
+
+    let accountAddress: Address | undefined = address
+
+    let chainId: number
+
+    const getMemoizedChainId = async () => {
+        if (chainId) return chainId
+        chainId = client.chain
+            ? client.chain.id
+            : await getAction(client, getChainId, "getChainId")({})
+        return chainId
+    }
+
+    const getFactoryArgs = async () => {
+        return {
+            factory: safeProxyFactoryAddress,
+            factoryData: await getAccountInitCode({
+                owners,
+                threshold,
+                safeModuleSetupAddress,
+                safe4337ModuleAddress,
+                safeSingletonAddress,
+                safeWebAuthnSharedSignerAddress,
+                safeP256VerifierAddress,
+                multiSendAddress,
+                erc7579LaunchpadAddress,
+                saltNonce,
+                setupTransactions,
+                safeModules,
+                validators,
+                executors,
+                fallbacks,
+                hooks,
+                attesters,
+                attestersThreshold,
+                paymentToken,
+                payment,
+                paymentReceiver
+            })
+        }
+    }
+
+    return toSmartAccount({
+        client,
+        entryPoint,
+        getFactoryArgs,
+        async getAddress() {
+            if (accountAddress) return accountAddress
+
+            // Get the sender address based on the init code
+            accountAddress = await getAccountAddress({
+                client,
+                owners,
+                threshold,
+                safeModuleSetupAddress,
+                safe4337ModuleAddress,
+                safeProxyFactoryAddress,
+                safeSingletonAddress,
+                safeWebAuthnSharedSignerAddress,
+                safeP256VerifierAddress,
+                multiSendAddress,
+                erc7579LaunchpadAddress,
+                saltNonce,
+                setupTransactions,
+                safeModules,
+                validators,
+                executors,
+                fallbacks,
+                hooks,
+                attesters,
+                attestersThreshold,
+                paymentToken,
+                payment,
+                paymentReceiver
+            })
+
+            return accountAddress
+        },
+        async encodeCalls(calls) {
+            const hasMultipleCalls = calls.length > 1
+
+            if (erc7579LaunchpadAddress) {
+                const safeDeployed = await isSmartAccountDeployed(
+                    client,
+                    await this.getAddress()
+                )
+
+                if (!safeDeployed) {
+                    const initData = get7579LaunchPadInitData({
+                        safe4337ModuleAddress,
+                        safeSingletonAddress,
+                        erc7579LaunchpadAddress,
+                        safeWebAuthnSharedSignerAddress,
+                        owners,
+                        threshold,
+                        validators,
+                        executors,
+                        fallbacks,
+                        hooks,
+                        attesters,
+                        attestersThreshold
+                    })
+
+                    return encodeFunctionData({
+                        abi: setupSafeAbi,
+                        functionName: "setupSafe",
+                        args: [
+                            {
+                                ...initData,
+                                validators: initData.validators.map(
+                                    (validator) => ({
+                                        module: validator.address,
+                                        initData: validator.context
+                                    })
+                                ),
+                                callData: encode7579Calls({
+                                    mode: {
+                                        type: hasMultipleCalls
+                                            ? "batchcall"
+                                            : "call",
+                                        revertOnError: false,
+                                        selector: "0x",
+                                        context: "0x"
+                                    },
+                                    callData: calls
+                                })
+                            }
+                        ]
+                    })
+                }
+
+                return encode7579Calls({
+                    mode: {
+                        type: hasMultipleCalls ? "batchcall" : "call",
+                        revertOnError: false,
+                        selector: "0x",
+                        context: "0x"
+                    },
+                    callData: calls
+                })
+            }
+
+            let to: Address
+            let value: bigint
+            let data: Hex
+            let operationType = 0
+
+            if (hasMultipleCalls) {
+                to = multiSendCallOnlyAddress
+                value = BigInt(0)
+
+                data = encodeMultiSend(
+                    calls.map((tx) => ({
+                        to: tx.to,
+                        value: tx.value ?? 0n,
+                        data: tx.data ?? "0x",
+                        operation: 0
+                    }))
+                )
+                operationType = 1
+            } else {
+                const call = calls.length === 0 ? undefined : calls[0]
+
+                if (!call) {
+                    throw new Error("No calls to encode")
+                }
+
+                to = call.to
+                data = call.data ?? "0x"
+                value = call.value ?? 0n
+            }
+
+            const calldata = encodeFunctionData({
+                abi: executeUserOpWithErrorStringAbi,
+                functionName: "executeUserOpWithErrorString",
+                args: [to, value, data, operationType]
+            })
+
+            if (onchainIdentifier) {
+                return concat([calldata, onchainIdentifier])
+            }
+
+            return calldata
+        },
+        async decodeCalls(callData) {
+            try {
+                const decoded = decodeFunctionData({
+                    abi: setupSafeAbi,
+                    data: callData
+                })
+
+                return decode7579Calls(decoded.args[0].callData).callData
+            } catch {}
+
+            try {
+                return decode7579Calls(callData).callData
+            } catch {}
+
+            const decoded = decodeFunctionData({
+                abi: executeUserOpWithErrorStringAbi,
+                data: callData
+            })
+
+            const to = decoded.args[0]
+            const value = decoded.args[1]
+            const data = decoded.args[2]
+
+            if (to === multiSendCallOnlyAddress) {
+                const decodedMultiSend = decodeFunctionData({
+                    abi: multiSendAbi,
+                    data: data
+                })
+
+                const dataToDecode = decodedMultiSend.args[0]
+                const transactions: {
+                    to: Address
+                    value: bigint
+                    data: Hex
+                }[] = []
+
+                let position = 0
+                const dataLength = size(dataToDecode)
+
+                while (position < dataLength) {
+                    // skip the operation type
+                    position += 1
+
+                    const to = getAddress(
+                        slice(dataToDecode, position, position + 20)
+                    )
+                    position += 20
+
+                    const value = BigInt(
+                        slice(dataToDecode, position, position + 32)
+                    )
+                    position += 32
+
+                    const dataLength = Number(
+                        BigInt(slice(dataToDecode, position, position + 32)) *
+                            BigInt(2)
+                    )
+
+                    position += 32
+
+                    const data = slice(
+                        dataToDecode,
+                        position,
+                        position + dataLength
+                    )
+                    position += dataLength
+
+                    transactions.push({ to, value, data })
+                }
+
+                return transactions
+            }
+
+            return [{ to, value, data }]
+        },
+        async getNonce(args) {
+            return getAccountNonce(client, {
+                address: await this.getAddress(),
+                entryPointAddress: entryPoint.address,
+                key: nonceKey ?? args?.key
+            })
+        },
+        async getStubSignature() {
+            const signatures = owners.map((owner) => {
+                let signer = safeWebAuthnSharedSignerAddress
+                let dynamic = true
+                let data: Hex =
+                    "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c"
+
+                if (isWebAuthnAccount(owner)) {
+                    data = encodeAbiParameters(
+                        [
+                            { name: "authenticatorData", type: "bytes" },
+                            { name: "clientDataJSON", type: "string" },
+                            { name: "signature", type: "uint256[2]" }
+                        ],
+                        [
+                            "0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97631d00000000",
+                            '"origin":"http://somelargdomainheresothatwehaveenoughbytes.com","crossOrigin":false',
+                            [
+                                44941127272049826721201904734628716258498742255959991581049806490182030242267n,
+                                9910254599581058084911561569808925251374718953855182016200087235935345969636n
+                            ]
+                        ]
+                    )
+                } else {
+                    signer = owner.address
+                    dynamic = false
+                }
+
+                if (!signer) {
+                    throw new Error("No signer found")
+                }
+
+                return {
+                    signer,
+                    data,
+                    dynamic
+                }
+            })
+
+            return encodePacked(
+                ["uint48", "uint48", "bytes"],
+                [0, 0, concatSignatures(signatures)]
+            )
+        },
+        async sign({ hash }) {
+            return this.signMessage({ message: hash })
+        },
+        async signMessage({ message }) {
+            if (localOwners.length < Number(threshold)) {
+                throw new Error(
+                    "Owners length mismatch, currently not supported"
+                )
+            }
+
+            if (erc7579LaunchpadAddress && version === "1.5.0") {
+                throw new Error("Safe 7579 & version 1.5.0 are not compatible")
+            }
+
+            const messageHash = hashTypedData({
+                domain: {
+                    chainId: await getMemoizedChainId(),
+                    verifyingContract: await this.getAddress()
+                },
+                types: {
+                    SafeMessage: [{ name: "message", type: "bytes" }]
+                },
+                primaryType: "SafeMessage",
+                message: {
+                    message: generateSafeMessageMessage(message)
+                }
+            })
+
+            const signatures = await Promise.all(
+                localOwners.map(async (localOwner) => {
+                    let signer = safeWebAuthnSharedSignerAddress
+                    let data: Hex
+                    let dynamic = true
+
+                    if (isWebAuthnAccount(localOwner)) {
+                        data = await getWebAuthnSignature({
+                            owner: localOwner,
+                            hash: messageHash
+                        })
+                    } else {
+                        signer = localOwner.address
+                        data = adjustVInSignature(
+                            "eth_sign",
+                            await localOwner.signMessage({
+                                message: {
+                                    raw: toBytes(messageHash)
+                                }
+                            })
+                        )
+                        dynamic = false
+                    }
+
+                    if (!signer) {
+                        throw new Error("no signer found")
+                    }
+
+                    return {
+                        signer,
+                        dynamic,
+                        data
+                    }
+                })
+            )
+
+            const signatureBytes = concatSignatures(signatures)
+
+            return erc7579LaunchpadAddress
+                ? concat([zeroAddress, signatureBytes])
+                : signatureBytes
+        },
+        async signTypedData(typedData) {
+            if (localOwners.length < Number(threshold)) {
+                throw new Error(
+                    "Owners length mismatch, currently not supported"
+                )
+            }
+
+            if (erc7579LaunchpadAddress && version === "1.5.0") {
+                throw new Error("Safe 7579 & version 1.5.0 are not compatible")
+            }
+
+            const signatures = await Promise.all(
+                localOwners.map(async (localOwner) => {
+                    let signer = safeWebAuthnSharedSignerAddress
+                    let data: Hex
+                    let dynamic = true
+
+                    if (isWebAuthnAccount(localOwner)) {
+                        const messageHash = hashTypedData({
+                            domain: {
+                                chainId: await getMemoizedChainId(),
+                                verifyingContract: await this.getAddress()
+                            },
+                            types: {
+                                SafeMessage: [
+                                    { name: "message", type: "bytes" }
+                                ]
+                            },
+                            primaryType: "SafeMessage",
+                            message: {
+                                message: generateSafeMessageMessage(typedData)
+                            }
+                        })
+
+                        data = await getWebAuthnSignature({
+                            owner: localOwner,
+                            hash: messageHash
+                        })
+                    } else {
+                        signer = localOwner.address
+                        data = adjustVInSignature(
+                            "eth_signTypedData",
+                            await localOwner.signTypedData({
+                                domain: {
+                                    chainId: await getMemoizedChainId(),
+                                    verifyingContract: await this.getAddress()
+                                },
+                                types: {
+                                    SafeMessage: [
+                                        { name: "message", type: "bytes" }
+                                    ]
+                                },
+                                primaryType: "SafeMessage",
+                                message: {
+                                    message:
+                                        generateSafeMessageMessage(typedData)
+                                }
+                            })
+                        )
+                        dynamic = false
+                    }
+
+                    if (!signer) {
+                        throw new Error("no signer found")
+                    }
+
+                    return {
+                        signer,
+                        dynamic,
+                        data
+                    }
+                })
+            )
+
+            const signatureBytes = concatSignatures(signatures)
+
+            return erc7579LaunchpadAddress
+                ? concat([zeroAddress, signatureBytes])
+                : signatureBytes
+        },
+        async signUserOperation(parameters) {
+            const { chainId = await getMemoizedChainId(), ...userOperation } =
+                parameters
+
+            if (localOwners.length < Number(threshold)) {
+                throw new Error(
+                    "Owners length mismatch use SafeSmartAccount.signUserOperation from `permissionless/accounts/safe`"
+                )
+            }
+
+            let signatures: Hex | undefined = undefined
+
+            for (const owner of localOwners) {
+                signatures = await signUserOperation({
+                    ...userOperation,
+                    version,
+                    entryPoint,
+                    owners: localOwners,
+                    account: owner,
+                    chainId,
+                    signatures,
+                    validAfter,
+                    validUntil,
+                    safe4337ModuleAddress,
+                    safeWebAuthnSharedSignerAddress
+                })
+            }
+
+            if (!signatures) {
+                throw new Error("No signatures found")
+            }
+
+            return signatures
+        }
+    }) as Promise<ToSafeSmartAccountReturnType<entryPointVersion>>
+}