permissionless 0.0.12 → 0.0.13

package/_esm/accounts/privateKeyToSimpleSmartAccount.js

@@ -1,169 +1,18 @@
-import { BaseError, concatHex, encodeFunctionData } from "viem";
-import { privateKeyToAccount, toAccount } from "viem/accounts";
-import { getBytecode, getChainId } from "viem/actions";
-import { getAccountNonce } from "../actions/public/getAccountNonce.js";
-import { getSenderAddress } from "../actions/public/getSenderAddress.js";
-import { getUserOperationHash } from "../utils/getUserOperationHash.js";
-import {} from "./types.js";
-export class SignTransactionNotSupportedBySmartAccount extends BaseError {
-    constructor({ docsPath } = {}) {
-        super([
-            "A smart account cannot sign or send transaction, it can only sign message or userOperation.",
-            "Please send user operation instead."
-        ].join("\n"), {
-            docsPath,
-            docsSlug: "account"
-        });
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "SignTransactionNotSupportedBySmartAccount"
-        });
-    }
-}
-const getAccountInitCode = async (factoryAddress, owner, index = 0n) => {
-    if (!owner)
-        throw new Error("Owner account not found");
-    return concatHex([
-        factoryAddress,
-        encodeFunctionData({
-            abi: [
-                {
-                    inputs: [
-                        {
-                            internalType: "address",
-                            name: "owner",
-                            type: "address"
-                        },
-                        {
-                            internalType: "uint256",
-                            name: "salt",
-                            type: "uint256"
-                        }
-                    ],
-                    name: "createAccount",
-                    outputs: [
-                        {
-                            internalType: "contract SimpleAccount",
-                            name: "ret",
-                            type: "address"
-                        }
-                    ],
-                    stateMutability: "nonpayable",
-                    type: "function"
-                }
-            ],
-            functionName: "createAccount",
-            args: [owner, index]
-        })
-    ]);
-};
-const getAccountAddress = async ({ client, factoryAddress, entryPoint, owner }) => {
-    const initCode = await getAccountInitCode(factoryAddress, owner);
-    return getSenderAddress(client, {
-        initCode,
-        entryPoint
-    });
-};
+import {} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { signerToSimpleSmartAccount } from "./signerToSimpleSmartAccount.js";
 /**
  * @description Creates an Simple Account from a private key.
  *
  * @returns A Private Key Simple Account.
  */
-export async function privateKeyToSimpleSmartAccount(client, { privateKey, factoryAddress, entryPoint }) {
+export async function privateKeyToSimpleSmartAccount(client, { privateKey, factoryAddress, entryPoint, index = 0n }) {
     const privateKeyAccount = privateKeyToAccount(privateKey);
-    const [accountAddress, chainId] = await Promise.all([
-        getAccountAddress({
-            client,
-            factoryAddress,
-            entryPoint,
-            owner: privateKeyAccount.address
-        }),
-        getChainId(client)
-    ]);
-    if (!accountAddress)
-        throw new Error("Account address not found");
-    const account = toAccount({
-        address: accountAddress,
-        async signMessage({ message }) {
-            return privateKeyAccount.signMessage({ message });
-        },
-        async signTransaction(_, __) {
-            throw new SignTransactionNotSupportedBySmartAccount();
-        },
-        async signTypedData(typedData) {
-            return privateKeyAccount.signTypedData({ ...typedData, privateKey });
-        }
+    return signerToSimpleSmartAccount(client, {
+        signer: privateKeyAccount,
+        factoryAddress,
+        entryPoint,
+        index
     });
-    return {
-        ...account,
-        client: client,
-        publicKey: accountAddress,
-        entryPoint: entryPoint,
-        source: "privateKeySimpleSmartAccount",
-        async getNonce() {
-            return getAccountNonce(client, {
-                sender: accountAddress,
-                entryPoint: entryPoint
-            });
-        },
-        async signUserOperation(userOperation) {
-            return account.signMessage({
-                message: {
-                    raw: getUserOperationHash({
-                        userOperation,
-                        entryPoint: entryPoint,
-                        chainId: chainId
-                    })
-                }
-            });
-        },
-        async getInitCode() {
-            const contractCode = await getBytecode(client, {
-                address: accountAddress
-            });
-            if ((contractCode?.length ?? 0) > 2)
-                return "0x";
-            return getAccountInitCode(factoryAddress, privateKeyAccount.address);
-        },
-        async encodeDeployCallData(_) {
-            throw new Error("Simple account doesn't support account deployment");
-        },
-        async encodeCallData({ to, value, data }) {
-            return encodeFunctionData({
-                abi: [
-                    {
-                        inputs: [
-                            {
-                                internalType: "address",
-                                name: "dest",
-                                type: "address"
-                            },
-                            {
-                                internalType: "uint256",
-                                name: "value",
-                                type: "uint256"
-                            },
-                            {
-                                internalType: "bytes",
-                                name: "func",
-                                type: "bytes"
-                            }
-                        ],
-                        name: "execute",
-                        outputs: [],
-                        stateMutability: "nonpayable",
-                        type: "function"
-                    }
-                ],
-                functionName: "execute",
-                args: [to, value, data]
-            });
-        },
-        async getDummySignature() {
-            return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-        }
-    };
 }
 //# sourceMappingURL=privateKeyToSimpleSmartAccount.js.map

package/_esm/accounts/privateKeyToSimpleSmartAccount.js.map

@@ -1 +1 @@
-{"version":3,"file":"privateKeyToSimpleSmartAccount.js","sourceRoot":"","sources":["../../accounts/privateKeyToSimpleSmartAccount.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"privateKeyToSimpleSmartAccount.js","sourceRoot":"","sources":["../../accounts/privateKeyToSimpleSmartAccount.ts"],"names":[],"mappings":"AAAA,OAAO,EAMN,MAAM,MAAM,CAAA;AACb,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAEH,0BAA0B,EAC7B,MAAM,iCAAiC,CAAA;AAExC;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAIhD,MAAkC,EAClC,EACI,UAAU,EACV,cAAc,EACd,UAAU,EACV,KAAK,GAAG,EAAE,EAMb;IAED,MAAM,iBAAiB,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAA;IAEzD,OAAO,0BAA0B,CAAC,MAAM,EAAE;QACtC,MAAM,EAAE,iBAAiB;QACzB,cAAc;QACd,UAAU;QACV,KAAK;KACR,CAAC,CAAA;AACN,CAAC"}

package/_esm/accounts/signerToSafeSmartAccount.js

@@ -0,0 +1,499 @@
+import { concatHex, encodeFunctionData, encodePacked, getContractAddress, hashMessage, hashTypedData, hexToBigInt, keccak256, toBytes, zeroAddress } from "viem";
+import { toAccount } from "viem/accounts";
+import { getBytecode, getChainId, readContract, signMessage, signTypedData } from "viem/actions";
+import { getAccountNonce } from "../actions/public/getAccountNonce.js";
+import { SignTransactionNotSupportedBySmartAccount } from "./types.js";
+const EIP712_SAFE_OPERATION_TYPE = {
+    SafeOp: [
+        { type: "address", name: "safe" },
+        { type: "bytes", name: "callData" },
+        { type: "uint256", name: "nonce" },
+        { type: "uint256", name: "preVerificationGas" },
+        { type: "uint256", name: "verificationGasLimit" },
+        { type: "uint256", name: "callGasLimit" },
+        { type: "uint256", name: "maxFeePerGas" },
+        { type: "uint256", name: "maxPriorityFeePerGas" },
+        { type: "address", name: "entryPoint" }
+    ]
+};
+const SAFE_VERSION_TO_ADDRESSES_MAP = {
+    "1.4.1": {
+        ADD_MODULES_LIB_ADDRESS: "0x191EFDC03615B575922289DC339F4c70aC5C30Af",
+        SAFE_4337_MODULE_ADDRESS: "0x39E54Bb2b3Aa444b4B39DEe15De3b7809c36Fc38",
+        SAFE_PROXY_FACTORY_ADDRESS: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67",
+        SAFE_SINGLETON_ADDRESS: "0x41675C099F32341bf84BFc5382aF534df5C7461a",
+        MULTI_SEND_ADDRESS: "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526",
+        MULTI_SEND_CALL_ONLY_ADDRESS: "0x9641d764fc13c8B624c04430C7356C1C7C8102e2"
+    }
+};
+const adjustVInSignature = (signingMethod, signature) => {
+    const ETHEREUM_V_VALUES = [0, 1, 27, 28];
+    const MIN_VALID_V_VALUE_FOR_SAFE_ECDSA = 27;
+    let signatureV = 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));
+};
+const generateSafeMessageMessage = (message) => {
+    const signableMessage = message;
+    if (typeof signableMessage === "string" || signableMessage.raw) {
+        return hashMessage(signableMessage);
+    }
+    return hashTypedData(message);
+};
+const encodeInternalTransaction = (tx) => {
+    const encoded = encodePacked(["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) => {
+    const data = `0x${txs
+        .map((tx) => encodeInternalTransaction(tx))
+        .join("")}`;
+    return encodeFunctionData({
+        abi: [
+            {
+                inputs: [
+                    {
+                        internalType: "bytes",
+                        name: "transactions",
+                        type: "bytes"
+                    }
+                ],
+                name: "multiSend",
+                outputs: [],
+                stateMutability: "payable",
+                type: "function"
+            }
+        ],
+        functionName: "multiSend",
+        args: [data]
+    });
+};
+const getInitializerCode = async ({ owner, addModuleLibAddress, safe4337ModuleAddress, multiSendAddress, setupTransactions = [], safeModules = [] }) => {
+    const multiSendCallData = encodeMultiSend([
+        {
+            to: addModuleLibAddress,
+            data: encodeFunctionData({
+                abi: [
+                    {
+                        inputs: [
+                            {
+                                internalType: "address[]",
+                                name: "modules",
+                                type: "address[]"
+                            }
+                        ],
+                        name: "enableModules",
+                        outputs: [],
+                        stateMutability: "nonpayable",
+                        type: "function"
+                    }
+                ],
+                functionName: "enableModules",
+                args: [[safe4337ModuleAddress, ...safeModules]]
+            }),
+            value: 0n,
+            operation: 1
+        },
+        ...setupTransactions.map((tx) => ({ ...tx, operation: 0 }))
+    ]);
+    return encodeFunctionData({
+        abi: [
+            {
+                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"
+            }
+        ],
+        functionName: "setup",
+        args: [
+            [owner],
+            1n,
+            multiSendAddress,
+            multiSendCallData,
+            safe4337ModuleAddress,
+            zeroAddress,
+            0n,
+            zeroAddress
+        ]
+    });
+};
+const getAccountInitCode = async ({ owner, addModuleLibAddress, safe4337ModuleAddress, safeProxyFactoryAddress, safeSingletonAddress, multiSendAddress, saltNonce = 0n, setupTransactions = [], safeModules = [] }) => {
+    if (!owner)
+        throw new Error("Owner account not found");
+    const initializer = await getInitializerCode({
+        owner,
+        addModuleLibAddress,
+        safe4337ModuleAddress,
+        multiSendAddress,
+        setupTransactions,
+        safeModules
+    });
+    const initCodeCallData = encodeFunctionData({
+        abi: [
+            {
+                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"
+            }
+        ],
+        functionName: "createProxyWithNonce",
+        args: [safeSingletonAddress, initializer, saltNonce]
+    });
+    return concatHex([safeProxyFactoryAddress, initCodeCallData]);
+};
+const getAccountAddress = async ({ client, owner, addModuleLibAddress, safe4337ModuleAddress, safeProxyFactoryAddress, safeSingletonAddress, multiSendAddress, setupTransactions = [], safeModules = [], saltNonce = 0n }) => {
+    const proxyCreationCode = await readContract(client, {
+        abi: [
+            {
+                inputs: [],
+                name: "proxyCreationCode",
+                outputs: [
+                    {
+                        internalType: "bytes",
+                        name: "",
+                        type: "bytes"
+                    }
+                ],
+                stateMutability: "pure",
+                type: "function"
+            }
+        ],
+        address: safeProxyFactoryAddress,
+        functionName: "proxyCreationCode"
+    });
+    const deploymentCode = encodePacked(["bytes", "uint256"], [proxyCreationCode, hexToBigInt(safeSingletonAddress)]);
+    const initializer = await getInitializerCode({
+        owner,
+        addModuleLibAddress,
+        safe4337ModuleAddress,
+        multiSendAddress,
+        setupTransactions,
+        safeModules
+    });
+    const salt = keccak256(encodePacked(["bytes32", "uint256"], [keccak256(encodePacked(["bytes"], [initializer])), saltNonce]));
+    return getContractAddress({
+        from: safeProxyFactoryAddress,
+        salt,
+        bytecode: deploymentCode,
+        opcode: "CREATE2"
+    });
+};
+const getDefaultAddresses = (safeVersion, { addModuleLibAddress: _addModuleLibAddress, safe4337ModuleAddress: _safe4337ModuleAddress, safeProxyFactoryAddress: _safeProxyFactoryAddress, safeSingletonAddress: _safeSingletonAddress, multiSendAddress: _multiSendAddress, multiSendCallOnlyAddress: _multiSendCallOnlyAddress }) => {
+    const addModuleLibAddress = _addModuleLibAddress ??
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion].ADD_MODULES_LIB_ADDRESS;
+    const safe4337ModuleAddress = _safe4337ModuleAddress ??
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion].SAFE_4337_MODULE_ADDRESS;
+    const safeProxyFactoryAddress = _safeProxyFactoryAddress ??
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion].SAFE_PROXY_FACTORY_ADDRESS;
+    const safeSingletonAddress = _safeSingletonAddress ??
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion].SAFE_SINGLETON_ADDRESS;
+    const multiSendAddress = _multiSendAddress ??
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion].MULTI_SEND_ADDRESS;
+    const multiSendCallOnlyAddress = _multiSendCallOnlyAddress ??
+        SAFE_VERSION_TO_ADDRESSES_MAP[safeVersion].MULTI_SEND_CALL_ONLY_ADDRESS;
+    return {
+        addModuleLibAddress,
+        safe4337ModuleAddress,
+        safeProxyFactoryAddress,
+        safeSingletonAddress,
+        multiSendAddress,
+        multiSendCallOnlyAddress
+    };
+};
+/**
+ * @description Creates an Simple Account from a private key.
+ *
+ * @returns A Private Key Simple Account.
+ */
+export async function signerToSafeSmartAccount(client, { signer, safeVersion, entryPoint, addModuleLibAddress: _addModuleLibAddress, safe4337ModuleAddress: _safe4337ModuleAddress, safeProxyFactoryAddress: _safeProxyFactoryAddress, safeSingletonAddress: _safeSingletonAddress, multiSendAddress: _multiSendAddress, multiSendCallOnlyAddress: _multiSendCallOnlyAddress, saltNonce = 0n, safeModules = [], setupTransactions = [] }) {
+    const chainId = await getChainId(client);
+    const viemSigner = signer.type === "local"
+        ? {
+            ...signer,
+            signTransaction: (_, __) => {
+                throw new SignTransactionNotSupportedBySmartAccount();
+            }
+        }
+        : signer;
+    const { addModuleLibAddress, safe4337ModuleAddress, safeProxyFactoryAddress, safeSingletonAddress, multiSendAddress, multiSendCallOnlyAddress } = getDefaultAddresses(safeVersion, {
+        addModuleLibAddress: _addModuleLibAddress,
+        safe4337ModuleAddress: _safe4337ModuleAddress,
+        safeProxyFactoryAddress: _safeProxyFactoryAddress,
+        safeSingletonAddress: _safeSingletonAddress,
+        multiSendAddress: _multiSendAddress,
+        multiSendCallOnlyAddress: _multiSendCallOnlyAddress
+    });
+    const accountAddress = await getAccountAddress({
+        client,
+        owner: viemSigner.address,
+        addModuleLibAddress,
+        safe4337ModuleAddress,
+        safeProxyFactoryAddress,
+        safeSingletonAddress,
+        multiSendAddress,
+        saltNonce,
+        setupTransactions,
+        safeModules
+    });
+    if (!accountAddress)
+        throw new Error("Account address not found");
+    const account = toAccount({
+        address: accountAddress,
+        async signMessage({ message }) {
+            const messageHash = hashTypedData({
+                domain: {
+                    chainId: chainId,
+                    verifyingContract: accountAddress
+                },
+                types: {
+                    SafeMessage: [{ name: "message", type: "bytes" }]
+                },
+                primaryType: "SafeMessage",
+                message: {
+                    message: generateSafeMessageMessage(message)
+                }
+            });
+            return adjustVInSignature("eth_sign", await signMessage(client, {
+                account: viemSigner,
+                message: {
+                    raw: toBytes(messageHash)
+                }
+            }));
+        },
+        async signTransaction(_, __) {
+            throw new SignTransactionNotSupportedBySmartAccount();
+        },
+        async signTypedData(typedData) {
+            return adjustVInSignature("eth_signTypedData", await signTypedData(client, {
+                account: viemSigner,
+                domain: {
+                    chainId: chainId,
+                    verifyingContract: accountAddress
+                },
+                types: {
+                    SafeMessage: [{ name: "message", type: "bytes" }]
+                },
+                primaryType: "SafeMessage",
+                message: {
+                    message: generateSafeMessageMessage(typedData)
+                }
+            }));
+        }
+    });
+    return {
+        ...account,
+        client: client,
+        publicKey: accountAddress,
+        entryPoint: entryPoint,
+        source: "SafeSmartAccount",
+        async getNonce() {
+            return getAccountNonce(client, {
+                sender: accountAddress,
+                entryPoint: entryPoint
+            });
+        },
+        async signUserOperation(userOperation) {
+            // const timestamps = 0n
+            const signatures = [
+                {
+                    signer: viemSigner.address,
+                    data: await signTypedData(client, {
+                        account: viemSigner,
+                        domain: {
+                            chainId: chainId,
+                            verifyingContract: safe4337ModuleAddress
+                        },
+                        types: EIP712_SAFE_OPERATION_TYPE,
+                        primaryType: "SafeOp",
+                        message: {
+                            safe: accountAddress,
+                            callData: userOperation.callData,
+                            nonce: userOperation.nonce,
+                            preVerificationGas: userOperation.preVerificationGas,
+                            verificationGasLimit: userOperation.verificationGasLimit,
+                            callGasLimit: userOperation.callGasLimit,
+                            maxFeePerGas: userOperation.maxFeePerGas,
+                            maxPriorityFeePerGas: userOperation.maxPriorityFeePerGas,
+                            // signatureTimestamps: timestamps,
+                            entryPoint: entryPoint
+                        }
+                    })
+                }
+            ];
+            signatures.sort((left, right) => left.signer
+                .toLowerCase()
+                .localeCompare(right.signer.toLowerCase()));
+            let signatureBytes = "0x";
+            for (const sig of signatures) {
+                signatureBytes += sig.data.slice(2);
+            }
+            // const signatureWithTimestamps = encodePacked(
+            //     ["uint96", "bytes"],
+            //     [timestamps, signatureBytes]
+            // )
+            return signatureBytes;
+        },
+        async getInitCode() {
+            const contractCode = await getBytecode(client, {
+                address: accountAddress
+            });
+            if ((contractCode?.length ?? 0) > 2)
+                return "0x";
+            return getAccountInitCode({
+                owner: viemSigner.address,
+                addModuleLibAddress,
+                safe4337ModuleAddress,
+                safeProxyFactoryAddress,
+                safeSingletonAddress,
+                multiSendAddress,
+                saltNonce,
+                setupTransactions,
+                safeModules
+            });
+        },
+        async encodeDeployCallData(_) {
+            throw new Error("Safe account doesn't support account deployment");
+        },
+        async encodeCallData(args) {
+            let to;
+            let value;
+            let data;
+            if (Array.isArray(args)) {
+                const argsArray = args;
+                to = multiSendCallOnlyAddress;
+                value = 0n;
+                data = encodeMultiSend(argsArray.map((tx) => ({ ...tx, operation: 0 })));
+            }
+            else {
+                const singleTransaction = args;
+                to = singleTransaction.to;
+                data = singleTransaction.data;
+                value = singleTransaction.value;
+            }
+            return encodeFunctionData({
+                abi: [
+                    {
+                        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: "executeUserOp",
+                        outputs: [],
+                        stateMutability: "nonpayable",
+                        type: "function"
+                    }
+                ],
+                functionName: "executeUserOp",
+                args: [to, value, data, 0]
+            });
+        },
+        async getDummySignature() {
+            return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+        }
+    };
+}
+//# sourceMappingURL=signerToSafeSmartAccount.js.map