near-safe 0.2.1 → 0.3.0

package/dist/cjs/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/cjs/lib/bundler.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Erc4337Bundler = void 0;
-// TODO: Ethers dependency is only for Generic HTTP Provider
-const ethers_1 = require("ethers");
 const viem_1 = require("viem");
 const util_1 = require("../util");
 function bundlerUrl(chainId, apikey) {
@@ -13,41 +11,37 @@ class Erc4337Bundler {
         this.entryPointAddress = entryPointAddress;
         this.apiKey = apiKey;
         this.chainId = chainId;
-        this.provider = new ethers_1.ethers.JsonRpcProvider(bundlerUrl(chainId, apiKey));
-    }
-    client(chainId) {
-        return new ethers_1.ethers.JsonRpcProvider(bundlerUrl(chainId, this.apiKey));
+        this.client = (0, viem_1.createPublicClient)({
+            transport: (0, viem_1.http)(bundlerUrl(chainId, this.apiKey)),
+            rpcSchema: (0, viem_1.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: util_1.PLACEHOLDER_SIG },
-                this.entryPointAddress,
-            ]);
-            return data;
+            return handleRequest(() => this.client.request({
+                method: "pm_sponsorUserOperation",
+                params: [
+                    { ...rawUserOp, signature: util_1.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;
@@ -58,8 +52,33 @@ class Erc4337Bundler {
         }
         return userOpReceipt;
     }
+    async _getUserOpReceiptInner(userOpHash) {
+        return handleRequest(() => this.client.request({
+            method: "eth_getUserOperationReceipt",
+            params: [userOpHash],
+        }));
+    }
 }
 exports.Erc4337Bundler = Erc4337Bundler;
+async function handleRequest(clientMethod) {
+    try {
+        return await clientMethod();
+    }
+    catch (error) {
+        if (error instanceof viem_1.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 viem_1.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) => {
     return {

package/dist/cjs/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 {};

package/dist/cjs/lib/safe.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractSuite = void 0;
 const safe_deployments_1 = require("@safe-global/safe-deployments");
 const safe_modules_deployments_1 = require("@safe-global/safe-modules-deployments");
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 const util_1 = require("../util");
 /**
  * All contracts used in account creation & execution
  */
 class ContractSuite {
-    constructor(provider, singleton, proxyFactory, m4337, moduleSetup, entryPoint) {
-        this.provider = provider;
+    constructor(client, singleton, proxyFactory, m4337, moduleSetup, entryPoint) {
+        this.dummyClient = client;
         this.singleton = singleton;
         this.proxyFactory = proxyFactory;
         this.m4337 = m4337;
@@ -19,109 +19,155 @@ class ContractSuite {
     }
     static async init() {
         // TODO - this is a cheeky hack.
-        const provider = new ethers_1.ethers.JsonRpcProvider("https://rpc2.sepolia.org");
-        const safeDeployment = (fn) => getDeployment(fn, { provider, version: "1.4.1" });
+        const client = (0, util_1.getClient)(11155111);
+        const safeDeployment = (fn) => getDeployment(fn, { version: "1.4.1" });
         const m4337Deployment = async (fn) => {
-            return getDeployment(fn, { provider, version: "0.3.0" });
+            return getDeployment(fn, { version: "0.3.0" });
         };
-        // Need this first to get entryPoint address
-        const m4337 = await m4337Deployment(safe_modules_deployments_1.getSafe4337ModuleDeployment);
-        const [singleton, proxyFactory, moduleSetup, supportedEntryPoint] = await Promise.all([
+        const [singleton, proxyFactory, moduleSetup, m4337] = await Promise.all([
             safeDeployment(safe_deployments_1.getSafeL2SingletonDeployment),
             safeDeployment(safe_deployments_1.getProxyFactoryDeployment),
             m4337Deployment(safe_modules_deployments_1.getSafeModuleSetupDeployment),
-            m4337.SUPPORTED_ENTRYPOINT(),
+            m4337Deployment(safe_modules_deployments_1.getSafe4337ModuleDeployment),
         ]);
-        const entryPoint = new ethers_1.ethers.Contract(supportedEntryPoint, ["function getNonce(address, uint192 key) view returns (uint256 nonce)"], provider);
-        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(),
+        // 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: (0, viem_1.parseAbi)([
+                "function getNonce(address, uint192 key) view returns (uint256 nonce)",
+            ]),
         });
-        return new ContractSuite(provider, singleton, proxyFactory, m4337, moduleSetup, entryPoint);
     }
     async addressForSetup(setup, saltNonce) {
         // bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
         // cf: https://github.com/safe-global/safe-smart-account/blob/499b17ad0191b575fcadc5cb5b8e3faeae5391ae/contracts/proxies/SafeProxyFactory.sol#L58
-        const salt = ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(["bytes32", "uint256"], [ethers_1.ethers.keccak256(setup), saltNonce || 0]));
+        const salt = (0, viem_1.keccak256)((0, viem_1.encodePacked)(["bytes32", "uint256"], [(0, viem_1.keccak256)(setup), BigInt(saltNonce || "0")]));
         // abi.encodePacked(type(SafeProxy).creationCode, uint256(uint160(_singleton)));
         // cf: https://github.com/safe-global/safe-smart-account/blob/499b17ad0191b575fcadc5cb5b8e3faeae5391ae/contracts/proxies/SafeProxyFactory.sol#L29
-        const initCode = ethers_1.ethers.solidityPacked(["bytes", "uint256"], [
-            await this.proxyFactory.proxyCreationCode(),
-            await this.singleton.getAddress(),
+        const initCode = (0, viem_1.encodePacked)(["bytes", "uint256"], [
+            (await this.dummyClient.readContract({
+                address: this.proxyFactory.address,
+                abi: this.proxyFactory.abi,
+                functionName: "proxyCreationCode",
+            })),
+            BigInt(this.singleton.address),
         ]);
-        return ethers_1.ethers.getCreate2Address(await this.proxyFactory.getAddress(), salt, ethers_1.ethers.keccak256(initCode));
+        return (0, viem_1.getCreate2Address)({
+            from: this.proxyFactory.address,
+            salt,
+            bytecodeHash: (0, viem_1.keccak256)(initCode),
+        });
     }
-    async getSetup(owners) {
-        const setup = await this.singleton.interface.encodeFunctionData("setup", [
-            owners,
-            1, // We use sign threshold of 1.
-            this.moduleSetup.target,
-            this.moduleSetup.interface.encodeFunctionData("enableModules", [
-                [this.m4337.target],
-            ]),
-            this.m4337.target,
-            ethers_1.ethers.ZeroAddress,
-            0,
-            ethers_1.ethers.ZeroAddress,
-        ]);
-        return setup;
+    getSetup(owners) {
+        return (0, viem_1.encodeFunctionData)({
+            abi: this.singleton.abi,
+            functionName: "setup",
+            args: [
+                owners,
+                1, // We use sign threshold of 1.
+                this.moduleSetup.address,
+                (0, viem_1.encodeFunctionData)({
+                    abi: this.moduleSetup.abi,
+                    functionName: "enableModules",
+                    args: [[this.m4337.address]],
+                }),
+                this.m4337.address,
+                viem_1.zeroAddress,
+                0,
+                viem_1.zeroAddress,
+            ],
+        });
+    }
+    addOwnerData(newOwner) {
+        return (0, viem_1.encodeFunctionData)({
+            abi: this.singleton.abi,
+            functionName: "addOwnerWithThreshold",
+            args: [newOwner, 1],
+        });
     }
     async getOpHash(unsignedUserOp) {
         const { factory, factoryData, verificationGasLimit, callGasLimit, maxPriorityFeePerGas, maxFeePerGas, } = unsignedUserOp;
-        return this.m4337.getOperationHash({
-            ...unsignedUserOp,
-            initCode: factory
-                ? ethers_1.ethers.solidityPacked(["address", "bytes"], [factory, factoryData])
-                : "0x",
-            accountGasLimits: (0, util_1.packGas)(verificationGasLimit, callGasLimit),
-            gasFees: (0, util_1.packGas)(maxPriorityFeePerGas, maxFeePerGas),
-            paymasterAndData: (0, util_1.packPaymasterData)(unsignedUserOp),
-            signature: util_1.PLACEHOLDER_SIG,
+        const opHash = await this.dummyClient.readContract({
+            address: this.m4337.address,
+            abi: this.m4337.abi,
+            functionName: "getOperationHash",
+            args: [
+                {
+                    ...unsignedUserOp,
+                    initCode: factory
+                        ? (0, viem_1.encodePacked)(["address", "bytes"], [factory, factoryData])
+                        : "0x",
+                    accountGasLimits: (0, util_1.packGas)(verificationGasLimit, callGasLimit),
+                    gasFees: (0, util_1.packGas)(maxPriorityFeePerGas, maxFeePerGas),
+                    paymasterAndData: (0, util_1.packPaymasterData)(unsignedUserOp),
+                    signature: util_1.PLACEHOLDER_SIG,
+                },
+            ],
         });
+        return opHash;
     }
     factoryDataForSetup(safeNotDeployed, setup, safeSaltNonce) {
         return safeNotDeployed
             ? {
-                factory: this.proxyFactory.target,
-                factoryData: this.proxyFactory.interface.encodeFunctionData("createProxyWithNonce", [this.singleton.target, setup, safeSaltNonce]),
+                factory: this.proxyFactory.address,
+                factoryData: (0, viem_1.encodeFunctionData)({
+                    abi: this.proxyFactory.abi,
+                    functionName: "createProxyWithNonce",
+                    args: [this.singleton.address, setup, safeSaltNonce],
+                }),
             }
             : {};
     }
-    async buildUserOp(txData, safeAddress, feeData, setup, safeNotDeployed, safeSaltNonce) {
-        const rawUserOp = {
+    async buildUserOp(nonce, txData, safeAddress, feeData, setup, safeNotDeployed, safeSaltNonce) {
+        return {
             sender: safeAddress,
-            nonce: ethers_1.ethers.toBeHex(await this.entryPoint.getNonce(safeAddress, 0)),
+            nonce: (0, viem_1.toHex)(nonce),
             ...this.factoryDataForSetup(safeNotDeployed, setup, safeSaltNonce),
             // <https://github.com/safe-global/safe-modules/blob/9a18245f546bf2a8ed9bdc2b04aae44f949ec7a0/modules/4337/contracts/Safe4337Module.sol#L172>
-            callData: this.m4337.interface.encodeFunctionData("executeUserOp", [
-                txData.to,
-                BigInt(txData.value),
-                txData.data,
-                txData.operation || 0,
-            ]),
+            callData: (0, viem_1.encodeFunctionData)({
+                abi: this.m4337.abi,
+                functionName: "executeUserOp",
+                args: [
+                    txData.to,
+                    BigInt(txData.value),
+                    txData.data,
+                    txData.operation || 0,
+                ],
+            }),
             ...feeData,
         };
-        return rawUserOp;
+    }
+    async getNonce(address, chainId) {
+        const nonce = (await (0, util_1.getClient)(chainId).readContract({
+            abi: this.entryPoint.abi,
+            address: this.entryPoint.address,
+            functionName: "getNonce",
+            args: [address, 0],
+        }));
+        return nonce;
     }
 }
 exports.ContractSuite = ContractSuite;
-async function getDeployment(fn, { provider, version }) {
-    const { chainId } = await provider.getNetwork();
+async function getDeployment(fn, { version }) {
     const deployment = fn({ version });
     if (!deployment) {
-        throw new Error(`Deployment not found for ${fn.name} version ${version} on chainId ${chainId}`);
-    }
-    let address = deployment.networkAddresses[`${chainId}`];
-    if (!address) {
-        // console.warn(
-        //   `Deployment asset ${fn.name} not listed on chainId ${chainId}, using likely fallback. For more info visit https://github.com/safe-global/safe-modules-deployments`
-        // );
-        // TODO: This is a cheeky hack. Real solution proposed in
-        // https://github.com/Mintbase/near-safe/issues/42
-        address = deployment.networkAddresses["11155111"];
+        throw new Error(`Deployment not found for ${fn.name} version ${version}`);
     }
-    return new ethers_1.ethers.Contract(address, deployment.abi, provider);
+    // TODO: maybe call parseAbi on deployment.abi here.
+    return {
+        address: deployment.networkAddresses["11155111"],
+        abi: deployment.abi,
+    };
 }

package/dist/cjs/tx-manager.d.ts

@@ -7,13 +7,12 @@ import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
 export declare class TransactionManager {
     readonly nearAdapter: NearEthAdapter;
     readonly address: Address;
-    readonly entryPointAddress: Address;
     private safePack;
     private setup;
     private pimlicoKey;
     private safeSaltNonce;
     private deployedChains;
-    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, entryPointAddress: Address, safeSaltNonce: string);
+    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, safeSaltNonce: string);
     static create(config: {
         accountId: string;
         mpcContractId: string;
@@ -22,6 +21,7 @@ export declare class TransactionManager {
         safeSaltNonce?: string;
     }): Promise<TransactionManager>;
     get mpcAddress(): Address;
+    get mpcContractId(): string;
     getBalance(chainId: number): Promise<bigint>;
     bundlerForChainId(chainId: number): Erc4337Bundler;
     buildTransaction(args: {
@@ -34,7 +34,7 @@ export declare class TransactionManager {
     encodeSignRequest(tx: BaseTx): Promise<NearEthTxData>;
     executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
     safeDeployed(chainId: number): Promise<boolean>;
-    addOwnerTx(address: string): MetaTransaction;
+    addOwnerTx(address: Address): MetaTransaction;
     safeSufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
     broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
         signature: Hex;

package/dist/cjs/tx-manager.js

@@ -8,11 +8,10 @@ const multisend_1 = require("./lib/multisend");
 const safe_1 = require("./lib/safe");
 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 +24,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;
     }
@@ -97,11 +100,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 +114,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) {

package/dist/cjs/util.d.ts

@@ -1,4 +1,4 @@
-import { Hex } from "viem";
+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 +6,6 @@ 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 {};

package/dist/cjs/util.js

@@ -4,6 +4,9 @@ exports.packGas = exports.PLACEHOLDER_SIG = void 0;
 exports.packSignature = packSignature;
 exports.packPaymasterData = packPaymasterData;
 exports.containsValue = containsValue;
+exports.isContract = isContract;
+exports.getClient = getClient;
+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)]);
@@ -24,3 +27,9 @@ 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;
+}

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.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 {};

package/dist/esm/lib/safe.js

@@ -1,19 +1,20 @@
 import { getProxyFactoryDeployment, getSafeL2SingletonDeployment, } from "@safe-global/safe-deployments";
 import { getSafe4337ModuleDeployment, getSafeModuleSetupDeployment, } from "@safe-global/safe-modules-deployments";
-import { ethers } from "ethers";
-import { PLACEHOLDER_SIG, packGas, packPaymasterData } from "../util";
+import { encodeFunctionData, encodePacked, getCreate2Address, keccak256, parseAbi, toHex, zeroAddress, } from "viem";
+import { PLACEHOLDER_SIG, getClient, packGas, packPaymasterData, } from "../util";
 /**
  * All contracts used in account creation & execution
  */
 export class ContractSuite {
-    provider;
+    // Used only for stateless contract reads.
+    dummyClient;
     singleton;
     proxyFactory;
     m4337;
     moduleSetup;
     entryPoint;
-    constructor(provider, singleton, proxyFactory, m4337, moduleSetup, entryPoint) {
-        this.provider = provider;
+    constructor(client, singleton, proxyFactory, m4337, moduleSetup, entryPoint) {
+        this.dummyClient = client;
         this.singleton = singleton;
         this.proxyFactory = proxyFactory;
         this.m4337 = m4337;
@@ -22,108 +23,154 @@ export class ContractSuite {
     }
     static async init() {
         // TODO - this is a cheeky hack.
-        const provider = new ethers.JsonRpcProvider("https://rpc2.sepolia.org");
-        const safeDeployment = (fn) => getDeployment(fn, { provider, version: "1.4.1" });
+        const client = getClient(11155111);
+        const safeDeployment = (fn) => getDeployment(fn, { version: "1.4.1" });
         const m4337Deployment = async (fn) => {
-            return getDeployment(fn, { provider, version: "0.3.0" });
+            return getDeployment(fn, { version: "0.3.0" });
         };
-        // Need this first to get entryPoint address
-        const m4337 = await m4337Deployment(getSafe4337ModuleDeployment);
-        const [singleton, proxyFactory, moduleSetup, supportedEntryPoint] = await Promise.all([
+        const [singleton, proxyFactory, moduleSetup, m4337] = await Promise.all([
             safeDeployment(getSafeL2SingletonDeployment),
             safeDeployment(getProxyFactoryDeployment),
             m4337Deployment(getSafeModuleSetupDeployment),
-            m4337.SUPPORTED_ENTRYPOINT(),
+            m4337Deployment(getSafe4337ModuleDeployment),
         ]);
-        const entryPoint = new ethers.Contract(supportedEntryPoint, ["function getNonce(address, uint192 key) view returns (uint256 nonce)"], provider);
-        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(),
+        // 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)",
+            ]),
         });
-        return new ContractSuite(provider, singleton, proxyFactory, m4337, moduleSetup, entryPoint);
     }
     async addressForSetup(setup, saltNonce) {
         // bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
         // cf: https://github.com/safe-global/safe-smart-account/blob/499b17ad0191b575fcadc5cb5b8e3faeae5391ae/contracts/proxies/SafeProxyFactory.sol#L58
-        const salt = ethers.keccak256(ethers.solidityPacked(["bytes32", "uint256"], [ethers.keccak256(setup), saltNonce || 0]));
+        const salt = keccak256(encodePacked(["bytes32", "uint256"], [keccak256(setup), BigInt(saltNonce || "0")]));
         // abi.encodePacked(type(SafeProxy).creationCode, uint256(uint160(_singleton)));
         // cf: https://github.com/safe-global/safe-smart-account/blob/499b17ad0191b575fcadc5cb5b8e3faeae5391ae/contracts/proxies/SafeProxyFactory.sol#L29
-        const initCode = ethers.solidityPacked(["bytes", "uint256"], [
-            await this.proxyFactory.proxyCreationCode(),
-            await this.singleton.getAddress(),
+        const initCode = encodePacked(["bytes", "uint256"], [
+            (await this.dummyClient.readContract({
+                address: this.proxyFactory.address,
+                abi: this.proxyFactory.abi,
+                functionName: "proxyCreationCode",
+            })),
+            BigInt(this.singleton.address),
         ]);
-        return ethers.getCreate2Address(await this.proxyFactory.getAddress(), salt, ethers.keccak256(initCode));
+        return getCreate2Address({
+            from: this.proxyFactory.address,
+            salt,
+            bytecodeHash: keccak256(initCode),
+        });
     }
-    async getSetup(owners) {
-        const setup = await this.singleton.interface.encodeFunctionData("setup", [
-            owners,
-            1, // We use sign threshold of 1.
-            this.moduleSetup.target,
-            this.moduleSetup.interface.encodeFunctionData("enableModules", [
-                [this.m4337.target],
-            ]),
-            this.m4337.target,
-            ethers.ZeroAddress,
-            0,
-            ethers.ZeroAddress,
-        ]);
-        return setup;
+    getSetup(owners) {
+        return encodeFunctionData({
+            abi: this.singleton.abi,
+            functionName: "setup",
+            args: [
+                owners,
+                1, // We use sign threshold of 1.
+                this.moduleSetup.address,
+                encodeFunctionData({
+                    abi: this.moduleSetup.abi,
+                    functionName: "enableModules",
+                    args: [[this.m4337.address]],
+                }),
+                this.m4337.address,
+                zeroAddress,
+                0,
+                zeroAddress,
+            ],
+        });
+    }
+    addOwnerData(newOwner) {
+        return encodeFunctionData({
+            abi: this.singleton.abi,
+            functionName: "addOwnerWithThreshold",
+            args: [newOwner, 1],
+        });
     }
     async getOpHash(unsignedUserOp) {
         const { factory, factoryData, verificationGasLimit, callGasLimit, maxPriorityFeePerGas, maxFeePerGas, } = unsignedUserOp;
-        return this.m4337.getOperationHash({
-            ...unsignedUserOp,
-            initCode: factory
-                ? ethers.solidityPacked(["address", "bytes"], [factory, factoryData])
-                : "0x",
-            accountGasLimits: packGas(verificationGasLimit, callGasLimit),
-            gasFees: packGas(maxPriorityFeePerGas, maxFeePerGas),
-            paymasterAndData: packPaymasterData(unsignedUserOp),
-            signature: PLACEHOLDER_SIG,
+        const opHash = await this.dummyClient.readContract({
+            address: this.m4337.address,
+            abi: this.m4337.abi,
+            functionName: "getOperationHash",
+            args: [
+                {
+                    ...unsignedUserOp,
+                    initCode: factory
+                        ? encodePacked(["address", "bytes"], [factory, factoryData])
+                        : "0x",
+                    accountGasLimits: packGas(verificationGasLimit, callGasLimit),
+                    gasFees: packGas(maxPriorityFeePerGas, maxFeePerGas),
+                    paymasterAndData: packPaymasterData(unsignedUserOp),
+                    signature: PLACEHOLDER_SIG,
+                },
+            ],
         });
+        return opHash;
     }
     factoryDataForSetup(safeNotDeployed, setup, safeSaltNonce) {
         return safeNotDeployed
             ? {
-                factory: this.proxyFactory.target,
-                factoryData: this.proxyFactory.interface.encodeFunctionData("createProxyWithNonce", [this.singleton.target, setup, safeSaltNonce]),
+                factory: this.proxyFactory.address,
+                factoryData: encodeFunctionData({
+                    abi: this.proxyFactory.abi,
+                    functionName: "createProxyWithNonce",
+                    args: [this.singleton.address, setup, safeSaltNonce],
+                }),
             }
             : {};
     }
-    async buildUserOp(txData, safeAddress, feeData, setup, safeNotDeployed, safeSaltNonce) {
-        const rawUserOp = {
+    async buildUserOp(nonce, txData, safeAddress, feeData, setup, safeNotDeployed, safeSaltNonce) {
+        return {
             sender: safeAddress,
-            nonce: ethers.toBeHex(await this.entryPoint.getNonce(safeAddress, 0)),
+            nonce: toHex(nonce),
             ...this.factoryDataForSetup(safeNotDeployed, setup, safeSaltNonce),
             // <https://github.com/safe-global/safe-modules/blob/9a18245f546bf2a8ed9bdc2b04aae44f949ec7a0/modules/4337/contracts/Safe4337Module.sol#L172>
-            callData: this.m4337.interface.encodeFunctionData("executeUserOp", [
-                txData.to,
-                BigInt(txData.value),
-                txData.data,
-                txData.operation || 0,
-            ]),
+            callData: encodeFunctionData({
+                abi: this.m4337.abi,
+                functionName: "executeUserOp",
+                args: [
+                    txData.to,
+                    BigInt(txData.value),
+                    txData.data,
+                    txData.operation || 0,
+                ],
+            }),
             ...feeData,
         };
-        return rawUserOp;
+    }
+    async getNonce(address, chainId) {
+        const nonce = (await getClient(chainId).readContract({
+            abi: this.entryPoint.abi,
+            address: this.entryPoint.address,
+            functionName: "getNonce",
+            args: [address, 0],
+        }));
+        return nonce;
     }
 }
-async function getDeployment(fn, { provider, version }) {
-    const { chainId } = await provider.getNetwork();
+async function getDeployment(fn, { version }) {
     const deployment = fn({ version });
     if (!deployment) {
-        throw new Error(`Deployment not found for ${fn.name} version ${version} on chainId ${chainId}`);
-    }
-    let address = deployment.networkAddresses[`${chainId}`];
-    if (!address) {
-        // console.warn(
-        //   `Deployment asset ${fn.name} not listed on chainId ${chainId}, using likely fallback. For more info visit https://github.com/safe-global/safe-modules-deployments`
-        // );
-        // TODO: This is a cheeky hack. Real solution proposed in
-        // https://github.com/Mintbase/near-safe/issues/42
-        address = deployment.networkAddresses["11155111"];
+        throw new Error(`Deployment not found for ${fn.name} version ${version}`);
     }
-    return new ethers.Contract(address, deployment.abi, provider);
+    // TODO: maybe call parseAbi on deployment.abi here.
+    return {
+        address: deployment.networkAddresses["11155111"],
+        abi: deployment.abi,
+    };
 }

package/dist/esm/tx-manager.d.ts

@@ -7,13 +7,12 @@ import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
 export declare class TransactionManager {
     readonly nearAdapter: NearEthAdapter;
     readonly address: Address;
-    readonly entryPointAddress: Address;
     private safePack;
     private setup;
     private pimlicoKey;
     private safeSaltNonce;
     private deployedChains;
-    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, entryPointAddress: Address, safeSaltNonce: string);
+    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, safeSaltNonce: string);
     static create(config: {
         accountId: string;
         mpcContractId: string;
@@ -22,6 +21,7 @@ export declare class TransactionManager {
         safeSaltNonce?: string;
     }): Promise<TransactionManager>;
     get mpcAddress(): Address;
+    get mpcContractId(): string;
     getBalance(chainId: number): Promise<bigint>;
     bundlerForChainId(chainId: number): Erc4337Bundler;
     buildTransaction(args: {
@@ -34,7 +34,7 @@ export declare class TransactionManager {
     encodeSignRequest(tx: BaseTx): Promise<NearEthTxData>;
     executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
     safeDeployed(chainId: number): Promise<boolean>;
-    addOwnerTx(address: string): MetaTransaction;
+    addOwnerTx(address: Address): MetaTransaction;
     safeSufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
     broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
         signature: Hex;

package/dist/esm/tx-manager.js

@@ -1,23 +1,21 @@
-import { Network, setupAdapter, signatureFromOutcome, } from "near-ca";
+import { setupAdapter, signatureFromOutcome, } from "near-ca";
 import { serializeSignature } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
 import { encodeMulti } from "./lib/multisend";
 import { ContractSuite } from "./lib/safe";
-import { packSignature } from "./util";
+import { getClient, isContract, packSignature } from "./util";
 export class TransactionManager {
     nearAdapter;
     address;
-    entryPointAddress;
     safePack;
     setup;
     pimlicoKey;
     safeSaltNonce;
     deployedChains;
-    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;
@@ -30,34 +28,38 @@ export class TransactionManager {
             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 = Network.fromChainId(chainId).client;
-        return await provider.getBalance({ address: this.address });
+        return await getClient(chainId).getBalance({ address: this.address });
     }
     bundlerForChainId(chainId) {
-        return new Erc4337Bundler(this.entryPointAddress, this.pimlicoKey, chainId);
+        return new 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 ? 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;
     }
@@ -102,11 +104,11 @@ export class TransactionManager {
         return userOpReceipt;
     }
     async safeDeployed(chainId) {
+        // Early exit if already known.
         if (chainId in this.deployedChains) {
             return true;
         }
-        const provider = Network.fromChainId(chainId).client;
-        const deployed = (await provider.getCode({ address: this.address })) !== "0x";
+        const deployed = await isContract(this.address, chainId);
         if (deployed) {
             this.deployedChains.add(chainId);
         }
@@ -116,7 +118,7 @@ export 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) {

package/dist/esm/util.d.ts

@@ -1,4 +1,4 @@
-import { Hex } from "viem";
+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 +6,6 @@ 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 {};

package/dist/esm/util.js

@@ -1,4 +1,5 @@
-import { concatHex, encodePacked, toHex } from "viem";
+import { Network } from "near-ca";
+import { concatHex, encodePacked, toHex, } from "viem";
 export const PLACEHOLDER_SIG = encodePacked(["uint48", "uint48"], [0, 0]);
 export const packGas = (hi, lo) => encodePacked(["uint128", "uint128"], [BigInt(hi), BigInt(lo)]);
 export function packSignature(signature, validFrom = 0, validTo = 0) {
@@ -17,3 +18,9 @@ export function packPaymasterData(data) {
 export function containsValue(transactions) {
     return transactions.some((tx) => tx.value !== "0");
 }
+export async function isContract(address, chainId) {
+    return (await getClient(chainId).getCode({ address })) !== undefined;
+}
+export function getClient(chainId) {
+    return Network.fromChainId(chainId).client;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -42,11 +42,9 @@
   "dependencies": {
     "@safe-global/safe-deployments": "^1.37.0",
     "@safe-global/safe-modules-deployments": "^2.2.0",
-    "ethers": "^6.13.1",
     "near-api-js": "^5.0.0",
     "near-ca": "^0.5.2",
-    "viem": "^2.16.5",
-    "yargs": "^17.7.2"
+    "viem": "^2.16.5"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
@@ -57,11 +55,16 @@
     "dotenv": "^16.4.5",
     "eslint": "^9.6.0",
     "eslint-plugin-import": "^2.30.0",
+    "ethers": "^6.13.1",
     "jest": "^29.7.0",
     "prettier": "^3.3.2",
     "ts-jest": "^29.1.5",
     "tsx": "^4.16.0",
     "typescript": "^5.5.2",
     "yargs": "^17.7.2"
+  },
+  "resolutions": {
+    "glob": "^9.0.0",
+    "base-x": "^3.0.0"
   }
 }