near-safe 0.2.1 → 0.3.1

package/dist/cjs/tx-manager.js

@@ -6,13 +6,13 @@ const viem_1 = require("viem");
 const bundler_1 = require("./lib/bundler");
 const multisend_1 = require("./lib/multisend");
 const safe_1 = require("./lib/safe");
+const safe_message_1 = require("./lib/safe-message");
 const util_1 = require("./util");
 class TransactionManager {
-    constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, entryPointAddress, safeSaltNonce) {
+    constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce) {
         this.nearAdapter = nearAdapter;
         this.safePack = safePack;
         this.pimlicoKey = pimlicoKey;
-        this.entryPointAddress = entryPointAddress;
         this.setup = setup;
         this.address = safeAddress;
         this.safeSaltNonce = safeSaltNonce;
@@ -25,34 +25,38 @@ class TransactionManager {
             safe_1.ContractSuite.init(),
         ]);
         console.log(`Near Adapter: ${nearAdapter.nearAccountId()} <> ${nearAdapter.address}`);
-        const setup = await safePack.getSetup([nearAdapter.address]);
+        const setup = safePack.getSetup([nearAdapter.address]);
         const safeAddress = await safePack.addressForSetup(setup, config.safeSaltNonce);
-        const entryPointAddress = (await safePack.entryPoint.getAddress());
         console.log(`Safe Address: ${safeAddress}`);
-        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, entryPointAddress, config.safeSaltNonce || "0");
+        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, config.safeSaltNonce || "0");
     }
     get mpcAddress() {
         return this.nearAdapter.address;
     }
+    get mpcContractId() {
+        return this.nearAdapter.mpcContract.contract.contractId;
+    }
     async getBalance(chainId) {
-        const provider = near_ca_1.Network.fromChainId(chainId).client;
-        return await provider.getBalance({ address: this.address });
+        return await (0, util_1.getClient)(chainId).getBalance({ address: this.address });
     }
     bundlerForChainId(chainId) {
-        return new bundler_1.Erc4337Bundler(this.entryPointAddress, this.pimlicoKey, chainId);
+        return new bundler_1.Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
     }
     async buildTransaction(args) {
         const { transactions, usePaymaster, chainId } = args;
-        const bundler = this.bundlerForChainId(chainId);
-        const gasFees = (await bundler.getGasPrice()).fast;
-        // Build Singular MetaTransaction for Multisend from transaction list.
         if (transactions.length === 0) {
             throw new Error("Empty transaction set!");
         }
+        const bundler = this.bundlerForChainId(chainId);
+        const [gasFees, nonce, safeDeployed] = await Promise.all([
+            bundler.getGasPrice(),
+            this.safePack.getNonce(this.address, chainId),
+            this.safeDeployed(chainId),
+        ]);
+        // Build Singular MetaTransaction for Multisend from transaction list.
         const tx = transactions.length > 1 ? (0, multisend_1.encodeMulti)(transactions) : transactions[0];
-        const safeNotDeployed = !(await this.safeDeployed(chainId));
-        const rawUserOp = await this.safePack.buildUserOp(tx, this.address, gasFees, this.setup, safeNotDeployed, this.safeSaltNonce);
-        const paymasterData = await bundler.getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed);
+        const rawUserOp = await this.safePack.buildUserOp(nonce, tx, this.address, gasFees.fast, this.setup, !safeDeployed, this.safeSaltNonce);
+        const paymasterData = await bundler.getPaymasterData(rawUserOp, usePaymaster, !safeDeployed);
         const unsignedUserOp = { ...rawUserOp, ...paymasterData };
         return unsignedUserOp;
     }
@@ -63,27 +67,15 @@ class TransactionManager {
     async opHash(userOp) {
         return this.safePack.getOpHash(userOp);
     }
-    async encodeSignRequest(tx) {
-        const unsignedUserOp = await this.buildTransaction({
-            chainId: tx.chainId,
-            transactions: [
-                {
-                    to: tx.to,
-                    value: (tx.value || 0n).toString(),
-                    data: tx.data || "0x",
-                },
-            ],
-            usePaymaster: true,
-        });
-        const safeOpHash = (await this.opHash(unsignedUserOp));
-        const signRequest = await this.nearAdapter.encodeSignRequest({
-            method: "hash",
-            chainId: 0,
-            params: safeOpHash,
-        });
+    async encodeSignRequest(signRequest, usePaymaster) {
+        const data = await this.requestRouter(signRequest, usePaymaster);
         return {
-            ...signRequest,
-            evmMessage: JSON.stringify(unsignedUserOp),
+            nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
+                path: this.nearAdapter.derivationPath,
+                payload: data.payload,
+                key_version: 0,
+            }),
+            ...data,
         };
     }
     async executeTransaction(chainId, userOp) {
@@ -97,11 +89,11 @@ class TransactionManager {
         return userOpReceipt;
     }
     async safeDeployed(chainId) {
+        // Early exit if already known.
         if (chainId in this.deployedChains) {
             return true;
         }
-        const provider = near_ca_1.Network.fromChainId(chainId).client;
-        const deployed = (await provider.getCode({ address: this.address })) !== "0x";
+        const deployed = await (0, util_1.isContract)(this.address, chainId);
         if (deployed) {
             this.deployedChains.add(chainId);
         }
@@ -111,7 +103,7 @@ class TransactionManager {
         return {
             to: this.address,
             value: "0",
-            data: this.safePack.singleton.interface.encodeFunctionData("addOwnerWithThreshold", [address, 1]),
+            data: this.safePack.addOwnerData(address),
         };
     }
     async safeSufficientlyFunded(chainId, transactions, gasCost) {
@@ -137,5 +129,56 @@ class TransactionManager {
             throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Handles routing of signature requests based on the provided method, chain ID, and parameters.
+     *
+     * @async
+     * @function requestRouter
+     * @param {SignRequestData} params - An object containing the method, chain ID, and request parameters.
+     * @returns {Promise<{ evmMessage: string; payload: number[]; recoveryData: RecoveryData }>}
+     * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
+     *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
+     */
+    async requestRouter({ method, chainId, params }, usePaymaster) {
+        const safeInfo = {
+            address: { value: this.address },
+            chainId: chainId.toString(),
+            // TODO: Should be able to read this from on chain.
+            version: "1.4.1+L2",
+        };
+        // TODO: We are provided with sender in the input, but also expect safeInfo.
+        // We should either confirm they agree or ignore one of the two.
+        switch (method) {
+            case "eth_signTypedData":
+            case "eth_signTypedData_v4":
+            case "eth_sign": {
+                const [sender, messageOrData] = params;
+                return (0, safe_message_1.safeMessageTxData)(method, (0, safe_message_1.decodeSafeMessage)(messageOrData, safeInfo), sender);
+            }
+            case "personal_sign": {
+                const [messageHash, sender] = params;
+                return (0, safe_message_1.safeMessageTxData)(method, (0, safe_message_1.decodeSafeMessage)(messageHash, safeInfo), sender);
+            }
+            case "eth_sendTransaction": {
+                const transactions = (0, util_1.metaTransactionsFromRequest)(params);
+                const userOp = await this.buildTransaction({
+                    chainId,
+                    transactions,
+                    usePaymaster,
+                });
+                const opHash = await this.opHash(userOp);
+                return {
+                    payload: (0, near_ca_1.toPayload)(opHash),
+                    evmMessage: JSON.stringify(userOp),
+                    recoveryData: {
+                        type: method,
+                        // TODO: Double check that this is sufficient for UI.
+                        // We may want to adapt and return the `MetaTransactions` instead.
+                        data: opHash,
+                    },
+                };
+            }
+        }
+    }
 }
 exports.TransactionManager = TransactionManager;

package/dist/cjs/util.d.ts

@@ -1,4 +1,5 @@
-import { Hex } from "viem";
+import { SessionRequestParams } from "near-ca";
+import { Address, Hex, PublicClient } from "viem";
 import { PaymasterData, MetaTransaction } from "./types";
 export declare const PLACEHOLDER_SIG: `0x${string}`;
 type IntLike = Hex | bigint | string | number;
@@ -6,4 +7,7 @@ export declare const packGas: (hi: IntLike, lo: IntLike) => string;
 export declare function packSignature(signature: `0x${string}`, validFrom?: number, validTo?: number): Hex;
 export declare function packPaymasterData(data: PaymasterData): Hex;
 export declare function containsValue(transactions: MetaTransaction[]): boolean;
+export declare function isContract(address: Address, chainId: number): Promise<boolean>;
+export declare function getClient(chainId: number): PublicClient;
+export declare function metaTransactionsFromRequest(params: SessionRequestParams): MetaTransaction[];
 export {};

package/dist/cjs/util.js

@@ -4,7 +4,12 @@ exports.packGas = exports.PLACEHOLDER_SIG = void 0;
 exports.packSignature = packSignature;
 exports.packPaymasterData = packPaymasterData;
 exports.containsValue = containsValue;
+exports.isContract = isContract;
+exports.getClient = getClient;
+exports.metaTransactionsFromRequest = metaTransactionsFromRequest;
+const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
+//
 exports.PLACEHOLDER_SIG = (0, viem_1.encodePacked)(["uint48", "uint48"], [0, 0]);
 const packGas = (hi, lo) => (0, viem_1.encodePacked)(["uint128", "uint128"], [BigInt(hi), BigInt(lo)]);
 exports.packGas = packGas;
@@ -24,3 +29,32 @@ function packPaymasterData(data) {
 function containsValue(transactions) {
     return transactions.some((tx) => tx.value !== "0");
 }
+async function isContract(address, chainId) {
+    return (await getClient(chainId).getCode({ address })) !== undefined;
+}
+function getClient(chainId) {
+    return near_ca_1.Network.fromChainId(chainId).client;
+}
+function metaTransactionsFromRequest(params) {
+    let transactions;
+    if ((0, viem_1.isHex)(params)) {
+        // If RLP hex is given, decode the transaction and build EthTransactionParams
+        const tx = (0, viem_1.parseTransaction)(params);
+        transactions = [
+            {
+                from: viem_1.zeroAddress, // TODO: This is a hack - but its unused.
+                to: tx.to,
+                value: tx.value ? (0, viem_1.toHex)(tx.value) : "0x00",
+                data: tx.data || "0x",
+            },
+        ];
+    }
+    else {
+        transactions = params;
+    }
+    return transactions.map((tx) => ({
+        to: tx.to,
+        value: tx.value || "0x00",
+        data: tx.data || "0x",
+    }));
+}

package/dist/esm/lib/bundler.d.ts

@@ -1,15 +1,37 @@
-import { ethers } from "ethers";
+import { Address, Hash, PublicClient, Transport } from "viem";
 import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+type BundlerRpcSchema = [
+    {
+        Method: "pm_sponsorUserOperation";
+        Parameters: [UnsignedUserOperation, Address];
+        ReturnType: PaymasterData;
+    },
+    {
+        Method: "eth_sendUserOperation";
+        Parameters: [UserOperation, Address];
+        ReturnType: Hash;
+    },
+    {
+        Method: "pimlico_getUserOperationGasPrice";
+        Parameters: [];
+        ReturnType: GasPrices;
+    },
+    {
+        Method: "eth_getUserOperationReceipt";
+        Parameters: [Hash];
+        ReturnType: UserOperationReceipt | null;
+    }
+];
 export declare class Erc4337Bundler {
-    provider: ethers.JsonRpcProvider;
-    entryPointAddress: string;
+    client: PublicClient<Transport, undefined, undefined, BundlerRpcSchema>;
+    entryPointAddress: Address;
     apiKey: string;
     chainId: number;
-    constructor(entryPointAddress: string, apiKey: string, chainId: number);
-    client(chainId: number): ethers.JsonRpcProvider;
+    constructor(entryPointAddress: Address, apiKey: string, chainId: number);
     getPaymasterData(rawUserOp: UnsignedUserOperation, usePaymaster: boolean, safeNotDeployed: boolean): Promise<PaymasterData>;
-    sendUserOperation(userOp: UserOperation): Promise<string>;
+    sendUserOperation(userOp: UserOperation): Promise<Hash>;
     getGasPrice(): Promise<GasPrices>;
-    _getUserOpReceiptInner(userOpHash: string): Promise<UserOperationReceipt | null>;
-    getUserOpReceipt(userOpHash: string): Promise<UserOperationReceipt>;
+    getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;
+    private _getUserOpReceiptInner;
 }
+export {};

package/dist/esm/lib/bundler.js

@@ -1,12 +1,10 @@
-// TODO: Ethers dependency is only for Generic HTTP Provider
-import { ethers } from "ethers";
-import { toHex } from "viem";
+import { createPublicClient, http, rpcSchema, toHex, RpcError, HttpRequestError, } from "viem";
 import { PLACEHOLDER_SIG } from "../util";
 function bundlerUrl(chainId, apikey) {
     return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${apikey}`;
 }
 export class Erc4337Bundler {
-    provider;
+    client;
     entryPointAddress;
     apiKey;
     chainId;
@@ -14,41 +12,37 @@ export class Erc4337Bundler {
         this.entryPointAddress = entryPointAddress;
         this.apiKey = apiKey;
         this.chainId = chainId;
-        this.provider = new ethers.JsonRpcProvider(bundlerUrl(chainId, apiKey));
-    }
-    client(chainId) {
-        return new ethers.JsonRpcProvider(bundlerUrl(chainId, this.apiKey));
+        this.client = createPublicClient({
+            transport: http(bundlerUrl(chainId, this.apiKey)),
+            rpcSchema: rpcSchema(),
+        });
     }
     async getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed) {
         // TODO: Keep this option out of the bundler
         if (usePaymaster) {
             console.log("Requesting paymaster data...");
-            const data = this.provider.send("pm_sponsorUserOperation", [
-                { ...rawUserOp, signature: PLACEHOLDER_SIG },
-                this.entryPointAddress,
-            ]);
-            return data;
+            return handleRequest(() => this.client.request({
+                method: "pm_sponsorUserOperation",
+                params: [
+                    { ...rawUserOp, signature: PLACEHOLDER_SIG },
+                    this.entryPointAddress,
+                ],
+            }));
         }
         return defaultPaymasterData(safeNotDeployed);
     }
     async sendUserOperation(userOp) {
-        try {
-            const userOpHash = await this.provider.send("eth_sendUserOperation", [
-                userOp,
-                this.entryPointAddress,
-            ]);
-            return userOpHash;
-        }
-        catch (err) {
-            const error = err.error;
-            throw new Error(`Failed to send user op with: ${error.message}`);
-        }
+        return handleRequest(() => this.client.request({
+            method: "eth_sendUserOperation",
+            params: [userOp, this.entryPointAddress],
+        }));
+        // throw new Error(`Failed to send user op with: ${error.message}`);
     }
     async getGasPrice() {
-        return this.provider.send("pimlico_getUserOperationGasPrice", []);
-    }
-    async _getUserOpReceiptInner(userOpHash) {
-        return this.provider.send("eth_getUserOperationReceipt", [userOpHash]);
+        return handleRequest(() => this.client.request({
+            method: "pimlico_getUserOperationGasPrice",
+            params: [],
+        }));
     }
     async getUserOpReceipt(userOpHash) {
         let userOpReceipt = null;
@@ -59,6 +53,31 @@ export class Erc4337Bundler {
         }
         return userOpReceipt;
     }
+    async _getUserOpReceiptInner(userOpHash) {
+        return handleRequest(() => this.client.request({
+            method: "eth_getUserOperationReceipt",
+            params: [userOpHash],
+        }));
+    }
+}
+async function handleRequest(clientMethod) {
+    try {
+        return await clientMethod();
+    }
+    catch (error) {
+        if (error instanceof HttpRequestError) {
+            if (error.status === 401) {
+                throw new Error("Unauthorized request. Please check your API key.");
+            }
+            else {
+                console.error(`Request failed with status ${error.status}: ${error.message}`);
+            }
+        }
+        else if (error instanceof RpcError) {
+            throw new Error(`Failed to send user op with: ${error.message}`);
+        }
+        throw new Error(`Unexpected error ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 // TODO(bh2smith) Should probably get reasonable estimates here:
 const defaultPaymasterData = (safeNotDeployed) => {

package/dist/esm/lib/safe-message.d.ts

@@ -0,0 +1,27 @@
+import { type SafeInfo } from "@safe-global/safe-gateway-typescript-sdk";
+import { EIP712TypedData, RecoveryData } from "near-ca";
+import { Address, Hash } from "viem";
+export type DecodedSafeMessage = {
+    decodedMessage: string | EIP712TypedData;
+    safeMessageMessage: string;
+    safeMessageHash: Hash;
+};
+export type MinimalSafeInfo = Pick<SafeInfo, "address" | "version" | "chainId">;
+/**
+ * Returns the decoded message, the hash of the `message` and the hash of the `safeMessage`.
+ * The `safeMessageMessage` is the value inside the SafeMessage and the `safeMessageHash` gets signed if the connected wallet does not support `eth_signTypedData`.
+ *
+ * @param message message as string, UTF-8 encoded hex string or EIP-712 Typed Data
+ * @param safe SafeInfo of the opened Safe
+ * @returns `{
+ *   decodedMessage,
+ *   safeMessageMessage,
+ *   safeMessageHash
+ * }`
+ */
+export declare function decodeSafeMessage(message: string | EIP712TypedData, safe: MinimalSafeInfo): DecodedSafeMessage;
+export declare function safeMessageTxData(method: string, message: DecodedSafeMessage, sender: Address): {
+    evmMessage: string;
+    payload: number[];
+    recoveryData: RecoveryData;
+};

package/dist/esm/lib/safe-message.js

@@ -0,0 +1,108 @@
+import { toPayload } from "near-ca";
+import { gte } from "semver";
+import { fromHex, hashMessage, hashTypedData, isHex, } from "viem";
+/*
+ * From v1.3.0, EIP-1271 support was moved to the CompatibilityFallbackHandler.
+ * Also 1.3.0 introduces the chainId in the domain part of the SafeMessage
+ */
+const EIP1271_FALLBACK_HANDLER_SUPPORTED_SAFE_VERSION = "1.3.0";
+const generateSafeMessageMessage = (message) => {
+    return typeof message === "string"
+        ? hashMessage(message)
+        : hashTypedData(message);
+};
+/**
+ * Generates `SafeMessage` typed data for EIP-712
+ * https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L12
+ * @param safe Safe which will sign the message
+ * @param message Message to sign
+ * @returns `SafeMessage` types for signing
+ */
+const generateSafeMessageTypedData = ({ version, chainId, address }, message) => {
+    if (!version) {
+        throw Error("Cannot create SafeMessage without version information");
+    }
+    const isHandledByFallbackHandler = gte(version, EIP1271_FALLBACK_HANDLER_SUPPORTED_SAFE_VERSION);
+    const verifyingContract = address.value;
+    return {
+        domain: isHandledByFallbackHandler
+            ? {
+                chainId: Number(BigInt(chainId)),
+                verifyingContract,
+            }
+            : { verifyingContract },
+        types: {
+            SafeMessage: [{ name: "message", type: "bytes" }],
+        },
+        message: {
+            message: generateSafeMessageMessage(message),
+        },
+        primaryType: "SafeMessage",
+    };
+};
+const generateSafeMessageHash = (safe, message) => {
+    const typedData = generateSafeMessageTypedData(safe, message);
+    return hashTypedData(typedData);
+};
+/**
+ * If message is a hex value and is Utf8 encoded string we decode it, else we return the raw message
+ * @param {string} message raw input message
+ * @returns {string}
+ */
+const getDecodedMessage = (message) => {
+    if (isHex(message)) {
+        try {
+            return fromHex(message, "string");
+        }
+        catch (e) {
+            // the hex string is not UTF8 encoding so return the raw message.
+        }
+    }
+    return message;
+};
+/**
+ * Returns the decoded message, the hash of the `message` and the hash of the `safeMessage`.
+ * The `safeMessageMessage` is the value inside the SafeMessage and the `safeMessageHash` gets signed if the connected wallet does not support `eth_signTypedData`.
+ *
+ * @param message message as string, UTF-8 encoded hex string or EIP-712 Typed Data
+ * @param safe SafeInfo of the opened Safe
+ * @returns `{
+ *   decodedMessage,
+ *   safeMessageMessage,
+ *   safeMessageHash
+ * }`
+ */
+export function decodeSafeMessage(message, safe) {
+    const decodedMessage = typeof message === "string" ? getDecodedMessage(message) : message;
+    return {
+        decodedMessage,
+        safeMessageMessage: generateSafeMessageMessage(decodedMessage),
+        safeMessageHash: generateSafeMessageHash(safe, decodedMessage),
+    };
+}
+export function safeMessageTxData(method, message, sender) {
+    return {
+        evmMessage: message.safeMessageMessage,
+        payload: toPayload(message.safeMessageHash),
+        recoveryData: {
+            type: method,
+            data: {
+                address: sender,
+                // TODO - Upgrade Signable Message in near-ca
+                // @ts-expect-error: Type 'string | EIP712TypedData' is not assignable to type 'SignableMessage'.
+                message: decodedMessage,
+            },
+        },
+    };
+}
+// const isEIP712TypedData = (obj: any): obj is EIP712TypedData => {
+//   return (
+//     typeof obj === "object" &&
+//     obj != null &&
+//     "domain" in obj &&
+//     "types" in obj &&
+//     "message" in obj
+//   );
+// };
+// export const isBlindSigningPayload = (obj: EIP712TypedData | string): boolean =>
+//   !isEIP712TypedData(obj) && isHash(obj);

package/dist/esm/lib/safe.d.ts

@@ -1,24 +1,27 @@
-import { ethers } from "ethers";
-import { Address, Hash, Hex } from "viem";
+import { Address, Hash, Hex, ParseAbi, PublicClient } from "viem";
 import { GasPrice, MetaTransaction, UnsignedUserOperation, UserOperation } from "../types";
+interface DeploymentData {
+    abi: unknown[] | ParseAbi<readonly string[]>;
+    address: `0x${string}`;
+}
 /**
  * All contracts used in account creation & execution
  */
 export declare class ContractSuite {
-    provider: ethers.JsonRpcProvider;
-    singleton: ethers.Contract;
-    proxyFactory: ethers.Contract;
-    m4337: ethers.Contract;
-    moduleSetup: ethers.Contract;
-    entryPoint: ethers.Contract;
-    constructor(provider: ethers.JsonRpcProvider, singleton: ethers.Contract, proxyFactory: ethers.Contract, m4337: ethers.Contract, moduleSetup: ethers.Contract, entryPoint: ethers.Contract);
+    dummyClient: PublicClient;
+    singleton: DeploymentData;
+    proxyFactory: DeploymentData;
+    m4337: DeploymentData;
+    moduleSetup: DeploymentData;
+    entryPoint: DeploymentData;
+    constructor(client: PublicClient, singleton: DeploymentData, proxyFactory: DeploymentData, m4337: DeploymentData, moduleSetup: DeploymentData, entryPoint: DeploymentData);
     static init(): Promise<ContractSuite>;
-    addressForSetup(setup: ethers.BytesLike, saltNonce?: string): Promise<Address>;
-    getSetup(owners: string[]): Promise<Hex>;
+    addressForSetup(setup: Hex, saltNonce?: string): Promise<Address>;
+    getSetup(owners: string[]): Hex;
+    addOwnerData(newOwner: Address): Hex;
     getOpHash(unsignedUserOp: UserOperation): Promise<Hash>;
-    factoryDataForSetup(safeNotDeployed: boolean, setup: string, safeSaltNonce: string): {
-        factory?: Address;
-        factoryData?: Hex;
-    };
-    buildUserOp(txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
+    private factoryDataForSetup;
+    buildUserOp(nonce: bigint, txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
+    getNonce(address: Address, chainId: number): Promise<bigint>;
 }
+export {};