near-safe 0.3.1 → 0.4.0

package/dist/esm/{index.d.ts → src/index.d.ts}

@@ -1,4 +1,4 @@
-export * from "./tx-manager";
+export * from "./near-safe";
 export * from "./types";
 export * from "./util";
 export { Network, BaseTx, SignRequestData, populateTx } from "near-ca";

package/dist/esm/{index.js → src/index.js}

@@ -1,4 +1,4 @@
-export * from "./tx-manager";
+export * from "./near-safe";
 export * from "./types";
 export * from "./util";
 export { Network, populateTx } from "near-ca";

package/dist/{cjs → esm/src}/lib/bundler.d.ts

@@ -34,4 +34,5 @@ export declare class Erc4337Bundler {
     getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;
     private _getUserOpReceiptInner;
 }
+export declare function stripApiKey(error: unknown): string;
 export {};

package/dist/esm/{lib → src/lib}/bundler.js

@@ -65,18 +65,19 @@ async function handleRequest(clientMethod) {
         return await clientMethod();
     }
     catch (error) {
+        const message = stripApiKey(error);
         if (error instanceof HttpRequestError) {
             if (error.status === 401) {
-                throw new Error("Unauthorized request. Please check your API key.");
+                throw new Error("Unauthorized request. Please check your Pimlico API key.");
             }
             else {
-                console.error(`Request failed with status ${error.status}: ${error.message}`);
+                throw new Error(`Pimlico: ${message}`);
             }
         }
         else if (error instanceof RpcError) {
-            throw new Error(`Failed to send user op with: ${error.message}`);
+            throw new Error(`Failed to send user op with: ${message}`);
         }
-        throw new Error(`Unexpected error ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Bundler Request: ${message}`);
     }
 }
 // TODO(bh2smith) Should probably get reasonable estimates here:
@@ -87,3 +88,12 @@ const defaultPaymasterData = (safeNotDeployed) => {
         preVerificationGas: toHex(100000),
     };
 };
+export function stripApiKey(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/(apikey=)[^\s&]+/, "$1***");
+    // Could also do this with slicing.
+    // const keyStart = message.indexOf("apikey=") + 7;
+    // // If no apikey in the message, return it as is.
+    // if (keyStart === -1) return message;
+    // return `${message.slice(0, keyStart)}***${message.slice(keyStart + 36)}`;
+}

package/dist/esm/{lib → src/lib}/safe-message.d.ts

@@ -1,6 +1,6 @@
 import { type SafeInfo } from "@safe-global/safe-gateway-typescript-sdk";
-import { EIP712TypedData, RecoveryData } from "near-ca";
-import { Address, Hash } from "viem";
+import { EIP712TypedData } from "near-ca";
+import { Hash } from "viem";
 export type DecodedSafeMessage = {
     decodedMessage: string | EIP712TypedData;
     safeMessageMessage: string;
@@ -20,8 +20,3 @@ export type MinimalSafeInfo = Pick<SafeInfo, "address" | "version" | "chainId">;
  * }`
  */
 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 → src/lib}/safe-message.js

@@ -1,4 +1,3 @@
-import { toPayload } from "near-ca";
 import { gte } from "semver";
 import { fromHex, hashMessage, hashTypedData, isHex, } from "viem";
 /*
@@ -80,21 +79,6 @@ export function decodeSafeMessage(message, safe) {
         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" &&

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

@@ -0,0 +1,21 @@
+import { Address, Hash, Hex, PublicClient } from "viem";
+import { Deployment, GasPrice, MetaTransaction, UnsignedUserOperation, UserOperation } from "../types";
+/**
+ * All contracts used in account creation & execution
+ */
+export declare class SafeContractSuite {
+    dummyClient: PublicClient;
+    singleton: Deployment;
+    proxyFactory: Deployment;
+    m4337: Deployment;
+    moduleSetup: Deployment;
+    entryPoint: Deployment;
+    constructor();
+    addressForSetup(setup: Hex, saltNonce?: string): Promise<Address>;
+    getSetup(owners: string[]): Hex;
+    addOwnerData(newOwner: Address): Hex;
+    getOpHash(unsignedUserOp: UserOperation): Promise<Hash>;
+    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>;
+}

package/dist/esm/{lib → src/lib}/safe.js

@@ -1,11 +1,10 @@
-import { getProxyFactoryDeployment, getSafeL2SingletonDeployment, } from "@safe-global/safe-deployments";
-import { getSafe4337ModuleDeployment, getSafeModuleSetupDeployment, } from "@safe-global/safe-modules-deployments";
-import { encodeFunctionData, encodePacked, getCreate2Address, keccak256, parseAbi, toHex, zeroAddress, } from "viem";
+import { encodeFunctionData, encodePacked, getCreate2Address, keccak256, toHex, zeroAddress, } from "viem";
+import { SAFE_DEPLOYMENTS } from "../_gen/deployments";
 import { PLACEHOLDER_SIG, getClient, packGas, packPaymasterData, } from "../util";
 /**
  * All contracts used in account creation & execution
  */
-export class ContractSuite {
+export class SafeContractSuite {
     // Used only for stateless contract reads.
     dummyClient;
     singleton;
@@ -13,46 +12,14 @@ export class ContractSuite {
     m4337;
     moduleSetup;
     entryPoint;
-    constructor(client, singleton, proxyFactory, m4337, moduleSetup, entryPoint) {
-        this.dummyClient = client;
-        this.singleton = singleton;
-        this.proxyFactory = proxyFactory;
-        this.m4337 = m4337;
-        this.moduleSetup = moduleSetup;
-        this.entryPoint = entryPoint;
-    }
-    static async init() {
-        // TODO - this is a cheeky hack.
-        const client = getClient(11155111);
-        const safeDeployment = (fn) => getDeployment(fn, { version: "1.4.1" });
-        const m4337Deployment = async (fn) => {
-            return getDeployment(fn, { version: "0.3.0" });
-        };
-        const [singleton, proxyFactory, moduleSetup, m4337] = await Promise.all([
-            safeDeployment(getSafeL2SingletonDeployment),
-            safeDeployment(getProxyFactoryDeployment),
-            m4337Deployment(getSafeModuleSetupDeployment),
-            m4337Deployment(getSafe4337ModuleDeployment),
-        ]);
-        // console.log("Initialized ERC4337 & Safe Module Contracts:", {
-        //   singleton: await singleton.getAddress(),
-        //   proxyFactory: await proxyFactory.getAddress(),
-        //   m4337: await m4337.getAddress(),
-        //   moduleSetup: await moduleSetup.getAddress(),
-        //   entryPoint: await entryPoint.getAddress(),
-        // });
-        return new ContractSuite(client, singleton, proxyFactory, m4337, moduleSetup, 
-        // EntryPoint:
-        {
-            address: (await client.readContract({
-                address: m4337.address,
-                abi: m4337.abi,
-                functionName: "SUPPORTED_ENTRYPOINT",
-            })),
-            abi: parseAbi([
-                "function getNonce(address, uint192 key) view returns (uint256 nonce)",
-            ]),
-        });
+    constructor() {
+        this.dummyClient = getClient(11155111);
+        const deployments = SAFE_DEPLOYMENTS;
+        this.singleton = deployments.singleton;
+        this.proxyFactory = deployments.proxyFactory;
+        this.m4337 = deployments.m4337;
+        this.moduleSetup = deployments.moduleSetup;
+        this.entryPoint = deployments.entryPoint;
     }
     async addressForSetup(setup, saltNonce) {
         // bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
@@ -163,14 +130,3 @@ export class ContractSuite {
         return nonce;
     }
 }
-async function getDeployment(fn, { version }) {
-    const deployment = fn({ version });
-    if (!deployment) {
-        throw new Error(`Deployment not found for ${fn.name} version ${version}`);
-    }
-    // TODO: maybe call parseAbi on deployment.abi here.
-    return {
-        address: deployment.networkAddresses["11155111"],
-        abi: deployment.abi,
-    };
-}

package/dist/esm/{tx-manager.d.ts → src/near-safe.d.ts}

@@ -1,29 +1,29 @@
+import { NearConfig } from "near-api-js/lib/near";
 import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, SignRequestData, NearEthTxData, RecoveryData } from "near-ca";
+import { NearEthAdapter, SignRequestData } from "near-ca";
 import { Address, Hash, Hex } from "viem";
-import { Erc4337Bundler } from "./lib/bundler";
-import { ContractSuite } from "./lib/safe";
-import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
-export declare class TransactionManager {
+import { SafeContractSuite } from "./lib/safe";
+import { EncodedTxData, MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
+export interface NearSafeConfig {
+    accountId: string;
+    mpcContractId: string;
+    pimlicoKey: string;
+    nearConfig?: NearConfig;
+    privateKey?: string;
+    safeSaltNonce?: string;
+}
+export declare class NearSafe {
     readonly nearAdapter: NearEthAdapter;
     readonly address: Address;
     private safePack;
     private setup;
     private pimlicoKey;
     private safeSaltNonce;
-    private deployedChains;
-    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, safeSaltNonce: string);
-    static create(config: {
-        accountId: string;
-        mpcContractId: string;
-        pimlicoKey: string;
-        privateKey?: string;
-        safeSaltNonce?: string;
-    }): Promise<TransactionManager>;
+    static create(config: NearSafeConfig): Promise<NearSafe>;
+    constructor(nearAdapter: NearEthAdapter, safePack: SafeContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, safeSaltNonce: string);
     get mpcAddress(): Address;
     get mpcContractId(): string;
     getBalance(chainId: number): Promise<bigint>;
-    bundlerForChainId(chainId: number): Erc4337Bundler;
     buildTransaction(args: {
         chainId: number;
         transactions: MetaTransaction[];
@@ -31,15 +31,16 @@ export declare class TransactionManager {
     }): Promise<UserOperation>;
     signTransaction(safeOpHash: Hex): Promise<Hex>;
     opHash(userOp: UserOperation): Promise<Hash>;
-    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<NearEthTxData>;
-    executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
-    safeDeployed(chainId: number): Promise<boolean>;
-    addOwnerTx(address: Address): MetaTransaction;
-    safeSufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
+    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
     broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
         signature: Hex;
         receipt: UserOperationReceipt;
     }>;
+    executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
+    safeDeployed(chainId: number): Promise<boolean>;
+    sufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
+    addOwnerTx(address: Address): MetaTransaction;
+    private bundlerForChainId;
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
      *
@@ -53,6 +54,6 @@ export declare class TransactionManager {
     requestRouter({ method, chainId, params }: SignRequestData, usePaymaster: boolean): Promise<{
         evmMessage: string;
         payload: number[];
-        recoveryData: RecoveryData;
+        hash: Hash;
     }>;
 }

package/dist/esm/{tx-manager.js → src/near-safe.js}

@@ -2,37 +2,37 @@ import { setupAdapter, signatureFromOutcome, toPayload, } from "near-ca";
 import { serializeSignature } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
 import { encodeMulti } from "./lib/multisend";
-import { ContractSuite } from "./lib/safe";
-import { decodeSafeMessage, safeMessageTxData } from "./lib/safe-message";
+import { SafeContractSuite } from "./lib/safe";
+import { decodeSafeMessage } from "./lib/safe-message";
 import { getClient, isContract, metaTransactionsFromRequest, packSignature, } from "./util";
-export class TransactionManager {
+export class NearSafe {
     nearAdapter;
     address;
     safePack;
     setup;
     pimlicoKey;
     safeSaltNonce;
-    deployedChains;
+    static async create(config) {
+        const { pimlicoKey, safeSaltNonce } = config;
+        const nearAdapter = await setupAdapter({ ...config });
+        const safePack = new SafeContractSuite();
+        const setup = safePack.getSetup([nearAdapter.address]);
+        const safeAddress = await safePack.addressForSetup(setup, safeSaltNonce);
+        console.log(`
+      Near Adapter:
+        Near Account ID: ${nearAdapter.nearAccountId()}
+        MPC EOA: ${nearAdapter.address}
+        Safe: ${safeAddress}
+    `);
+        return new NearSafe(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce || "0");
+    }
     constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce) {
         this.nearAdapter = nearAdapter;
+        this.address = safeAddress;
+        this.setup = setup;
         this.safePack = safePack;
         this.pimlicoKey = pimlicoKey;
-        this.setup = setup;
-        this.address = safeAddress;
         this.safeSaltNonce = safeSaltNonce;
-        this.deployedChains = new Set();
-    }
-    static async create(config) {
-        const { pimlicoKey } = config;
-        const [nearAdapter, safePack] = await Promise.all([
-            setupAdapter({ ...config }),
-            ContractSuite.init(),
-        ]);
-        console.log(`Near Adapter: ${nearAdapter.nearAccountId()} <> ${nearAdapter.address}`);
-        const setup = safePack.getSetup([nearAdapter.address]);
-        const safeAddress = await safePack.addressForSetup(setup, config.safeSaltNonce);
-        console.log(`Safe Address: ${safeAddress}`);
-        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, config.safeSaltNonce || "0");
     }
     get mpcAddress() {
         return this.nearAdapter.address;
@@ -43,9 +43,6 @@ export class TransactionManager {
     async getBalance(chainId) {
         return await getClient(chainId).getBalance({ address: this.address });
     }
-    bundlerForChainId(chainId) {
-        return new Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
-    }
     async buildTransaction(args) {
         const { transactions, usePaymaster, chainId } = args;
         if (transactions.length === 0) {
@@ -72,16 +69,35 @@ export class TransactionManager {
         return this.safePack.getOpHash(userOp);
     }
     async encodeSignRequest(signRequest, usePaymaster) {
-        const data = await this.requestRouter(signRequest, usePaymaster);
+        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, usePaymaster);
         return {
             nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
                 path: this.nearAdapter.derivationPath,
-                payload: data.payload,
+                payload,
                 key_version: 0,
             }),
-            ...data,
+            evmData: {
+                chainId: signRequest.chainId,
+                data: evmMessage,
+                hash,
+            },
         };
     }
+    async broadcastEvm(chainId, outcome, unsignedUserOp) {
+        const signature = packSignature(serializeSignature(signatureFromOutcome(outcome)));
+        try {
+            return {
+                signature,
+                receipt: await this.executeTransaction(chainId, {
+                    ...unsignedUserOp,
+                    signature,
+                }),
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async executeTransaction(chainId, userOp) {
         const bundler = this.bundlerForChainId(chainId);
         const userOpHash = await bundler.sendUserOperation(userOp);
@@ -93,15 +109,15 @@ export class TransactionManager {
         return userOpReceipt;
     }
     async safeDeployed(chainId) {
-        // Early exit if already known.
-        if (chainId in this.deployedChains) {
+        return isContract(this.address, chainId);
+    }
+    async sufficientlyFunded(chainId, transactions, gasCost) {
+        const txValue = transactions.reduce((acc, tx) => acc + BigInt(tx.value), 0n);
+        if (txValue + gasCost === 0n) {
             return true;
         }
-        const deployed = await isContract(this.address, chainId);
-        if (deployed) {
-            this.deployedChains.add(chainId);
-        }
-        return deployed;
+        const safeBalance = await this.getBalance(chainId);
+        return txValue + gasCost < safeBalance;
     }
     addOwnerTx(address) {
         return {
@@ -110,28 +126,8 @@ export class TransactionManager {
             data: this.safePack.addOwnerData(address),
         };
     }
-    async safeSufficientlyFunded(chainId, transactions, gasCost) {
-        const txValue = transactions.reduce((acc, tx) => acc + BigInt(tx.value), 0n);
-        if (txValue + gasCost === 0n) {
-            return true;
-        }
-        const safeBalance = await this.getBalance(chainId);
-        return txValue + gasCost < safeBalance;
-    }
-    async broadcastEvm(chainId, outcome, unsignedUserOp) {
-        const signature = packSignature(serializeSignature(signatureFromOutcome(outcome)));
-        try {
-            return {
-                signature,
-                receipt: await this.executeTransaction(chainId, {
-                    ...unsignedUserOp,
-                    signature,
-                }),
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    bundlerForChainId(chainId) {
+        return new Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
     }
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
@@ -156,12 +152,22 @@ export class TransactionManager {
             case "eth_signTypedData":
             case "eth_signTypedData_v4":
             case "eth_sign": {
-                const [sender, messageOrData] = params;
-                return safeMessageTxData(method, decodeSafeMessage(messageOrData, safeInfo), sender);
+                const [_, messageOrData] = params;
+                const message = decodeSafeMessage(messageOrData, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: toPayload(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
             }
             case "personal_sign": {
-                const [messageHash, sender] = params;
-                return safeMessageTxData(method, decodeSafeMessage(messageHash, safeInfo), sender);
+                const [messageHash, _] = params;
+                const message = decodeSafeMessage(messageHash, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: toPayload(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
             }
             case "eth_sendTransaction": {
                 const transactions = metaTransactionsFromRequest(params);
@@ -174,12 +180,7 @@ export class TransactionManager {
                 return {
                     payload: 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,
-                    },
+                    hash: await this.opHash(userOp),
                 };
             }
         }

package/dist/esm/{types.d.ts → src/types.d.ts}

@@ -1,4 +1,16 @@
-import { Address, Hex } from "viem";
+import { FunctionCallTransaction, SignArgs } from "near-ca";
+import { Address, Hash, Hex, ParseAbi, TransactionSerializable } from "viem";
+export type SafeDeployments = {
+    singleton: Deployment;
+    proxyFactory: Deployment;
+    moduleSetup: Deployment;
+    m4337: Deployment;
+    entryPoint: Deployment;
+};
+export interface Deployment {
+    abi: unknown[] | ParseAbi<readonly string[]>;
+    address: Address;
+}
 export interface UnsignedUserOperation {
     sender: Address;
     nonce: string;
@@ -89,4 +101,14 @@ export interface MetaTransaction {
     readonly data: string;
     readonly operation?: OperationType;
 }
+export interface EncodedTxData {
+    evmData: {
+        chainId: number;
+        data: string | TransactionSerializable;
+        hash: Hash;
+    };
+    nearPayload: FunctionCallTransaction<{
+        request: SignArgs;
+    }>;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -32,6 +32,7 @@
     "build": "rm -fr dist/* && yarn build:esm && yarn build:cjs",
     "build:esm": "tsc -p tsconfig.esm.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:deployments": "tsx scripts/safe-deployments.ts && prettier --write 'src/_gen/**/*.ts'",
     "start": "yarn example",
     "example": "tsx examples/send-tx.ts",
     "lint": "eslint . --ignore-pattern dist/",
@@ -40,15 +41,15 @@
     "all": "yarn fmt && yarn lint && yarn build"
   },
   "dependencies": {
-    "@safe-global/safe-deployments": "^1.37.0",
     "@safe-global/safe-gateway-typescript-sdk": "^3.22.2",
-    "@safe-global/safe-modules-deployments": "^2.2.0",
     "near-api-js": "^5.0.0",
     "near-ca": "^0.5.6",
     "semver": "^7.6.3",
     "viem": "^2.16.5"
   },
   "devDependencies": {
+    "@safe-global/safe-deployments": "^1.37.0",
+    "@safe-global/safe-modules-deployments": "^2.2.0",
     "@types/jest": "^29.5.12",
     "@types/node": "^22.3.0",
     "@types/semver": "^7.5.8",

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

@@ -1,27 +0,0 @@
-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 {
-    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: Hex, saltNonce?: string): Promise<Address>;
-    getSetup(owners: string[]): Hex;
-    addOwnerData(newOwner: Address): Hex;
-    getOpHash(unsignedUserOp: UserOperation): Promise<Hash>;
-    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 {};

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

@@ -1,27 +0,0 @@
-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 {
-    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: Hex, saltNonce?: string): Promise<Address>;
-    getSetup(owners: string[]): Hex;
-    addOwnerData(newOwner: Address): Hex;
-    getOpHash(unsignedUserOp: UserOperation): Promise<Hash>;
-    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 {};