near-safe 0.1.1 → 0.2.1

package/README.md

@@ -27,15 +27,16 @@ yarn install
 Create a `.env` (or use our `.env.sample`) file in the root of the project and add the following environment variables:
 
 ```sh
-ETH_RPC=https://rpc2.sepolia.org
-
 NEAR_ACCOUNT_ID=
-NEAR_ACCOUNT_PRIVATE_KEY=
-
 # Head to https://www.pimlico.io/ for an API key
 PIMLICO_KEY=
 ```
 
+To use the CLI tool provided here in `examples/*` you will also need to provide a privateKey for your Near account.
+
+```sh
+NEAR_ACCOUNT_PRIVATE_KEY=
+```
 
 ## Usage
 

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -14,6 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateTx = exports.Network = void 0;
 __exportStar(require("./tx-manager"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./util"), exports);
+var near_ca_1 = require("near-ca");
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return near_ca_1.Network; } });
+Object.defineProperty(exports, "populateTx", { enumerable: true, get: function () { return near_ca_1.populateTx; } });

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

@@ -3,7 +3,10 @@ import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOpe
 export declare class Erc4337Bundler {
     provider: ethers.JsonRpcProvider;
     entryPointAddress: string;
-    constructor(bundlerUrl: string, entryPointAddress: string);
+    apiKey: string;
+    chainId: number;
+    constructor(entryPointAddress: string, apiKey: string, chainId: number);
+    client(chainId: number): ethers.JsonRpcProvider;
     getPaymasterData(rawUserOp: UnsignedUserOperation, usePaymaster: boolean, safeNotDeployed: boolean): Promise<PaymasterData>;
     sendUserOperation(userOp: UserOperation): Promise<string>;
     getGasPrice(): Promise<GasPrices>;

package/dist/cjs/lib/bundler.js

@@ -1,12 +1,22 @@
 "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) {
+    return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${apikey}`;
+}
 class Erc4337Bundler {
-    constructor(bundlerUrl, entryPointAddress) {
+    constructor(entryPointAddress, apiKey, chainId) {
         this.entryPointAddress = entryPointAddress;
-        this.provider = new ethers_1.ethers.JsonRpcProvider(bundlerUrl);
+        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));
     }
     async getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed) {
         // TODO: Keep this option out of the bundler
@@ -53,8 +63,8 @@ exports.Erc4337Bundler = Erc4337Bundler;
 // TODO(bh2smith) Should probably get reasonable estimates here:
 const defaultPaymasterData = (safeNotDeployed) => {
     return {
-        verificationGasLimit: ethers_1.ethers.toBeHex(safeNotDeployed ? 500000 : 100000),
-        callGasLimit: ethers_1.ethers.toBeHex(100000),
-        preVerificationGas: ethers_1.ethers.toBeHex(100000),
+        verificationGasLimit: (0, viem_1.toHex)(safeNotDeployed ? 500000 : 100000),
+        callGasLimit: (0, viem_1.toHex)(100000),
+        preVerificationGas: (0, viem_1.toHex)(100000),
     };
 };

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

@@ -0,0 +1,3 @@
+import { MetaTransaction } from "../types";
+export declare const MULTI_SEND_ABI: string[];
+export declare function encodeMulti(transactions: readonly MetaTransaction[], multiSendContractAddress?: string): MetaTransaction;

package/dist/cjs/lib/multisend.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MULTI_SEND_ABI = void 0;
+exports.encodeMulti = encodeMulti;
+const viem_1 = require("viem");
+const types_1 = require("../types");
+exports.MULTI_SEND_ABI = ["function multiSend(bytes memory transactions)"];
+const MULTISEND_141 = "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526";
+const MULTISEND_CALLONLY_141 = "0x9641d764fc13c8B624c04430C7356C1C7C8102e2";
+/// Encodes the transaction as packed bytes of:
+/// - `operation` as a `uint8` with `0` for a `call` or `1` for a `delegatecall` (=> 1 byte),
+/// - `to` as an `address` (=> 20 bytes),
+/// - `value` as a `uint256` (=> 32 bytes),
+/// -  length of `data` as a `uint256` (=> 32 bytes),
+/// - `data` as `bytes`.
+const encodeMetaTx = (tx) => (0, viem_1.encodePacked)(["uint8", "address", "uint256", "uint256", "bytes"], [
+    tx.operation || types_1.OperationType.Call,
+    tx.to,
+    BigInt(tx.value),
+    BigInt((0, viem_1.size)(tx.data)),
+    tx.data,
+]);
+const remove0x = (hexString) => hexString.slice(2);
+// Encodes a batch of module transactions into a single multiSend module transaction.
+// A module transaction is an object with fields corresponding to a Gnosis Safe's (i.e., Zodiac IAvatar's) `execTransactionFromModule` method parameters.
+function encodeMulti(transactions, multiSendContractAddress = transactions.some((t) => t.operation === types_1.OperationType.DelegateCall)
+    ? MULTISEND_141
+    : MULTISEND_CALLONLY_141) {
+    const encodedTransactions = "0x" + transactions.map(encodeMetaTx).map(remove0x).join("");
+    return {
+        operation: types_1.OperationType.DelegateCall,
+        to: multiSendContractAddress,
+        value: "0x00",
+        data: (0, viem_1.encodeFunctionData)({
+            abi: (0, viem_1.parseAbi)(exports.MULTI_SEND_ABI),
+            functionName: "multiSend",
+            args: [encodedTransactions],
+        }),
+    };
+}

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

@@ -1,6 +1,6 @@
 import { ethers } from "ethers";
-import { GasPrice, UnsignedUserOperation, UserOperation } from "../types";
-import { MetaTransaction } from "ethers-multisend";
+import { Address, Hash, Hex } from "viem";
+import { GasPrice, MetaTransaction, UnsignedUserOperation, UserOperation } from "../types";
 /**
  * All contracts used in account creation & execution
  */
@@ -12,13 +12,13 @@ export declare class ContractSuite {
     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);
-    static init(provider: ethers.JsonRpcProvider): Promise<ContractSuite>;
-    addressForSetup(setup: ethers.BytesLike, saltNonce?: string): Promise<string>;
-    getSetup(owners: string[]): Promise<string>;
-    getOpHash(unsignedUserOp: UserOperation): Promise<string>;
+    static init(): Promise<ContractSuite>;
+    addressForSetup(setup: ethers.BytesLike, saltNonce?: string): Promise<Address>;
+    getSetup(owners: string[]): Promise<Hex>;
+    getOpHash(unsignedUserOp: UserOperation): Promise<Hash>;
     factoryDataForSetup(safeNotDeployed: boolean, setup: string, safeSaltNonce: string): {
-        factory?: ethers.AddressLike;
-        factoryData?: string;
+        factory?: Address;
+        factoryData?: Hex;
     };
-    buildUserOp(txData: MetaTransaction, safeAddress: ethers.AddressLike, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
+    buildUserOp(txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
 }

package/dist/cjs/lib/safe.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractSuite = void 0;
-const ethers_1 = require("ethers");
 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 util_1 = require("../util");
 /**
  * All contracts used in account creation & execution
@@ -17,16 +17,12 @@ class ContractSuite {
         this.moduleSetup = moduleSetup;
         this.entryPoint = entryPoint;
     }
-    static async init(provider) {
+    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 m4337Deployment = async (fn) => {
-            try {
-                return await getDeployment(fn, { provider, version: "0.3.0" });
-            }
-            catch (error) {
-                console.warn(error.message, "using v0.2.0");
-                return getDeployment(fn, { provider, version: "0.2.0" });
-            }
+            return getDeployment(fn, { provider, version: "0.3.0" });
         };
         // Need this first to get entryPoint address
         const m4337 = await m4337Deployment(safe_modules_deployments_1.getSafe4337ModuleDeployment);
@@ -73,16 +69,15 @@ class ContractSuite {
         ]);
         return setup;
     }
-    async getOpHash(unsignedUserOp
-    // paymasterData: PaymasterData
-    ) {
+    async getOpHash(unsignedUserOp) {
+        const { factory, factoryData, verificationGasLimit, callGasLimit, maxPriorityFeePerGas, maxFeePerGas, } = unsignedUserOp;
         return this.m4337.getOperationHash({
             ...unsignedUserOp,
-            initCode: unsignedUserOp.factory
-                ? ethers_1.ethers.solidityPacked(["address", "bytes"], [unsignedUserOp.factory, unsignedUserOp.factoryData])
+            initCode: factory
+                ? ethers_1.ethers.solidityPacked(["address", "bytes"], [factory, factoryData])
                 : "0x",
-            accountGasLimits: (0, util_1.packGas)(unsignedUserOp.verificationGasLimit, unsignedUserOp.callGasLimit),
-            gasFees: (0, util_1.packGas)(unsignedUserOp.maxPriorityFeePerGas, unsignedUserOp.maxFeePerGas),
+            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,
         });
@@ -116,8 +111,17 @@ exports.ContractSuite = ContractSuite;
 async function getDeployment(fn, { provider, version }) {
     const { chainId } = await provider.getNetwork();
     const deployment = fn({ version });
-    if (!deployment || !deployment.networkAddresses[`${chainId}`]) {
+    if (!deployment) {
         throw new Error(`Deployment not found for ${fn.name} version ${version} on chainId ${chainId}`);
     }
-    return new ethers_1.ethers.Contract(deployment.networkAddresses[`${chainId}`], deployment.abi, provider);
+    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"];
+    }
+    return new ethers_1.ethers.Contract(address, deployment.abi, provider);
 }

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

@@ -1,42 +1,43 @@
-import { ethers } from "ethers";
+import { FinalExecutionOutcome } from "near-api-js/lib/providers";
 import { NearEthAdapter, NearEthTxData, BaseTx } from "near-ca";
+import { Address, Hash, Hex } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
-import { UserOperation, UserOperationReceipt } from "./types";
-import { MetaTransaction } from "ethers-multisend";
 import { ContractSuite } from "./lib/safe";
+import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
 export declare class TransactionManager {
-    readonly provider: ethers.JsonRpcProvider;
     readonly nearAdapter: NearEthAdapter;
+    readonly address: Address;
+    readonly entryPointAddress: Address;
     private safePack;
-    private bundler;
     private setup;
-    readonly address: string;
-    readonly chainId: number;
+    private pimlicoKey;
     private safeSaltNonce;
-    private _safeNotDeployed;
-    constructor(provider: ethers.JsonRpcProvider, nearAdapter: NearEthAdapter, safePack: ContractSuite, bundler: Erc4337Bundler, setup: string, chainId: number, safeAddress: string, safeSaltNonce: string, safeNotDeployed: boolean);
+    private deployedChains;
+    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, entryPointAddress: Address, safeSaltNonce: string);
     static create(config: {
-        ethRpc: string;
+        accountId: string;
+        mpcContractId: string;
         pimlicoKey: string;
-        nearAdapter: NearEthAdapter;
+        privateKey?: string;
         safeSaltNonce?: string;
     }): Promise<TransactionManager>;
-    static fromChainId(args: {
-        chainId: number;
-        nearAdapter: NearEthAdapter;
-        pimlicoKey: string;
-    }): Promise<TransactionManager>;
-    get safeNotDeployed(): boolean;
-    get mpcAddress(): `0x${string}`;
-    getSafeBalance(): Promise<bigint>;
+    get mpcAddress(): Address;
+    getBalance(chainId: number): Promise<bigint>;
+    bundlerForChainId(chainId: number): Erc4337Bundler;
     buildTransaction(args: {
+        chainId: number;
         transactions: MetaTransaction[];
         usePaymaster: boolean;
     }): Promise<UserOperation>;
-    signTransaction(safeOpHash: string): Promise<string>;
-    opHash(userOp: UserOperation): Promise<string>;
+    signTransaction(safeOpHash: Hex): Promise<Hex>;
+    opHash(userOp: UserOperation): Promise<Hash>;
     encodeSignRequest(tx: BaseTx): Promise<NearEthTxData>;
-    executeTransaction(userOp: UserOperation): Promise<UserOperationReceipt>;
+    executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
+    safeDeployed(chainId: number): Promise<boolean>;
     addOwnerTx(address: string): MetaTransaction;
-    safeSufficientlyFunded(transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
+    safeSufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
+    broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
+        signature: Hex;
+        receipt: UserOperationReceipt;
+    }>;
 }

package/dist/cjs/tx-manager.js

@@ -1,82 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionManager = void 0;
-const ethers_1 = require("ethers");
 const near_ca_1 = require("near-ca");
+const viem_1 = require("viem");
 const bundler_1 = require("./lib/bundler");
-const util_1 = require("./util");
-const near_1 = require("./lib/near");
-const ethers_multisend_1 = require("ethers-multisend");
+const multisend_1 = require("./lib/multisend");
 const safe_1 = require("./lib/safe");
+const util_1 = require("./util");
 class TransactionManager {
-    constructor(provider, nearAdapter, safePack, bundler, setup, chainId, safeAddress, safeSaltNonce, safeNotDeployed) {
-        this.provider = provider;
+    constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, entryPointAddress, safeSaltNonce) {
         this.nearAdapter = nearAdapter;
         this.safePack = safePack;
-        this.bundler = bundler;
+        this.pimlicoKey = pimlicoKey;
+        this.entryPointAddress = entryPointAddress;
         this.setup = setup;
-        this.chainId = chainId;
         this.address = safeAddress;
         this.safeSaltNonce = safeSaltNonce;
-        this._safeNotDeployed = safeNotDeployed;
+        this.deployedChains = new Set();
     }
     static async create(config) {
-        const { nearAdapter, pimlicoKey } = config;
-        const provider = new ethers_1.ethers.JsonRpcProvider(config.ethRpc);
-        const chainId = (await provider.getNetwork()).chainId;
-        const safePack = await safe_1.ContractSuite.init(provider);
+        const { pimlicoKey } = config;
+        const [nearAdapter, safePack] = await Promise.all([
+            (0, near_ca_1.setupAdapter)({ ...config }),
+            safe_1.ContractSuite.init(),
+        ]);
         console.log(`Near Adapter: ${nearAdapter.nearAccountId()} <> ${nearAdapter.address}`);
-        const bundler = new bundler_1.Erc4337Bundler(`https://api.pimlico.io/v2/${chainId}/rpc?apikey=${pimlicoKey}`, await safePack.entryPoint.getAddress());
         const setup = await safePack.getSetup([nearAdapter.address]);
         const safeAddress = await safePack.addressForSetup(setup, config.safeSaltNonce);
-        const safeNotDeployed = (await provider.getCode(safeAddress)) === "0x";
-        console.log(`Safe Address: ${safeAddress} - deployed? ${!safeNotDeployed}`);
-        return new TransactionManager(provider, nearAdapter, safePack, bundler, setup, parseInt(chainId.toString()), safeAddress, config.safeSaltNonce || "0", safeNotDeployed);
-    }
-    static async fromChainId(args) {
-        const { pimlicoKey, nearAdapter } = args;
-        return TransactionManager.create({
-            ethRpc: near_ca_1.Network.fromChainId(args.chainId).rpcUrl,
-            pimlicoKey,
-            nearAdapter,
-        });
-    }
-    get safeNotDeployed() {
-        return this._safeNotDeployed;
+        const entryPointAddress = (await safePack.entryPoint.getAddress());
+        console.log(`Safe Address: ${safeAddress}`);
+        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, entryPointAddress, config.safeSaltNonce || "0");
     }
     get mpcAddress() {
         return this.nearAdapter.address;
     }
-    async getSafeBalance() {
-        return await this.provider.getBalance(this.address);
+    async getBalance(chainId) {
+        const provider = near_ca_1.Network.fromChainId(chainId).client;
+        return await provider.getBalance({ address: this.address });
+    }
+    bundlerForChainId(chainId) {
+        return new bundler_1.Erc4337Bundler(this.entryPointAddress, this.pimlicoKey, chainId);
     }
     async buildTransaction(args) {
-        const { transactions, usePaymaster } = args;
-        const gasFees = (await this.bundler.getGasPrice()).fast;
-        // const gasFees = await this.provider.getFeeData();
+        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 tx = transactions.length > 1 ? (0, ethers_multisend_1.encodeMulti)(transactions) : transactions[0];
-        const rawUserOp = await this.safePack.buildUserOp(tx, this.address, gasFees, this.setup, this.safeNotDeployed, this.safeSaltNonce);
-        const paymasterData = await this.bundler.getPaymasterData(rawUserOp, usePaymaster, this.safeNotDeployed);
+        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 unsignedUserOp = { ...rawUserOp, ...paymasterData };
         return unsignedUserOp;
     }
     async signTransaction(safeOpHash) {
-        const signature = await (0, near_1.getNearSignature)(this.nearAdapter, safeOpHash);
+        const signature = await this.nearAdapter.sign(safeOpHash);
         return (0, util_1.packSignature)(signature);
     }
     async opHash(userOp) {
         return this.safePack.getOpHash(userOp);
     }
     async encodeSignRequest(tx) {
-        // TODO - This is sloppy and ignores ChainId!
-        if (tx.chainId !== this.chainId) {
-            throw new Error(`Transaciton request for invalid ChainId ${tx.chainId} != ${this.chainId}`);
-        }
         const unsignedUserOp = await this.buildTransaction({
+            chainId: tx.chainId,
             transactions: [
                 {
                     to: tx.to,
@@ -97,16 +86,27 @@ class TransactionManager {
             evmMessage: JSON.stringify(unsignedUserOp),
         };
     }
-    async executeTransaction(userOp) {
-        const userOpHash = await this.bundler.sendUserOperation(userOp);
+    async executeTransaction(chainId, userOp) {
+        const bundler = this.bundlerForChainId(chainId);
+        const userOpHash = await bundler.sendUserOperation(userOp);
         console.log("UserOp Hash", userOpHash);
-        const userOpReceipt = await this.bundler.getUserOpReceipt(userOpHash);
+        const userOpReceipt = await bundler.getUserOpReceipt(userOpHash);
         console.log("userOp Receipt", userOpReceipt);
         // Update safeNotDeployed after the first transaction
-        this._safeNotDeployed =
-            (await this.provider.getCode(this.address)) === "0x";
+        this.safeDeployed(chainId);
         return userOpReceipt;
     }
+    async safeDeployed(chainId) {
+        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";
+        if (deployed) {
+            this.deployedChains.add(chainId);
+        }
+        return deployed;
+    }
     addOwnerTx(address) {
         return {
             to: this.address,
@@ -114,13 +114,28 @@ class TransactionManager {
             data: this.safePack.singleton.interface.encodeFunctionData("addOwnerWithThreshold", [address, 1]),
         };
     }
-    async safeSufficientlyFunded(transactions, gasCost) {
+    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.getSafeBalance();
+        const safeBalance = await this.getBalance(chainId);
         return txValue + gasCost < safeBalance;
     }
+    async broadcastEvm(chainId, outcome, unsignedUserOp) {
+        const signature = (0, util_1.packSignature)((0, viem_1.serializeSignature)((0, near_ca_1.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)}`);
+        }
+    }
 }
 exports.TransactionManager = TransactionManager;

package/dist/cjs/types.d.ts

@@ -1,30 +1,30 @@
-import { ethers } from "ethers";
+import { Address, Hex } from "viem";
 export interface UnsignedUserOperation {
-    sender: ethers.AddressLike;
+    sender: Address;
     nonce: string;
-    factory?: ethers.AddressLike;
-    factoryData?: ethers.BytesLike;
-    callData: string;
-    maxPriorityFeePerGas: string;
-    maxFeePerGas: string;
+    factory?: Address;
+    factoryData?: Hex;
+    callData: Hex;
+    maxPriorityFeePerGas: Hex;
+    maxFeePerGas: Hex;
 }
 /**
  * Supported Representation of UserOperation for EntryPoint v0.7
  */
 export interface UserOperation extends UnsignedUserOperation {
-    verificationGasLimit: string;
-    callGasLimit: string;
-    preVerificationGas: string;
-    signature?: string;
+    verificationGasLimit: Hex;
+    callGasLimit: Hex;
+    preVerificationGas: Hex;
+    signature?: Hex;
 }
 export interface PaymasterData {
-    paymaster?: string;
-    paymasterData?: string;
-    paymasterVerificationGasLimit?: string;
-    paymasterPostOpGasLimit?: string;
-    verificationGasLimit: string;
-    callGasLimit: string;
-    preVerificationGas: string;
+    paymaster?: Address;
+    paymasterData?: Hex;
+    paymasterVerificationGasLimit?: Hex;
+    paymasterPostOpGasLimit?: Hex;
+    verificationGasLimit: Hex;
+    callGasLimit: Hex;
+    preVerificationGas: Hex;
 }
 export interface UserOptions {
     usePaymaster: boolean;
@@ -32,10 +32,7 @@ export interface UserOptions {
     mpcContractId: string;
     recoveryAddress?: string;
 }
-export type TStatus = "success" | "reverted";
-export type Address = ethers.AddressLike;
-export type Hex = `0x${string}`;
-export type Hash = `0x${string}`;
+export type TxStatus = "success" | "reverted";
 interface Log {
     logIndex: string;
     transactionIndex: string;
@@ -49,19 +46,19 @@ interface Log {
 interface Receipt {
     transactionHash: Hex;
     transactionIndex: bigint;
-    blockHash: Hash;
+    blockHash: Hex;
     blockNumber: bigint;
     from: Address;
-    to: Address | null;
+    to?: Address;
     cumulativeGasUsed: bigint;
-    status: TStatus;
+    status: TxStatus;
     gasUsed: bigint;
-    contractAddress: Address | null;
+    contractAddress?: Address;
     logsBloom: Hex;
     effectiveGasPrice: bigint;
 }
 export type UserOperationReceipt = {
-    userOpHash: Hash;
+    userOpHash: Hex;
     entryPoint: Address;
     sender: Address;
     nonce: bigint;
@@ -82,4 +79,14 @@ export interface GasPrice {
     maxFeePerGas: Hex;
     maxPriorityFeePerGas: Hex;
 }
+export declare enum OperationType {
+    Call = 0,
+    DelegateCall = 1
+}
+export interface MetaTransaction {
+    readonly to: string;
+    readonly value: string;
+    readonly data: string;
+    readonly operation?: OperationType;
+}
 export {};

package/dist/cjs/types.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationType = void 0;
+var OperationType;
+(function (OperationType) {
+    OperationType[OperationType["Call"] = 0] = "Call";
+    OperationType[OperationType["DelegateCall"] = 1] = "DelegateCall";
+})(OperationType || (exports.OperationType = OperationType = {}));

package/dist/cjs/util.d.ts

@@ -1,8 +1,9 @@
-import { ethers } from "ethers";
-import { PaymasterData } from "./types";
-import { MetaTransaction } from "ethers-multisend";
-export declare const PLACEHOLDER_SIG: string;
-export declare const packGas: (hi: ethers.BigNumberish, lo: ethers.BigNumberish) => string;
-export declare function packSignature(signature: string, validFrom?: number, validTo?: number): string;
-export declare function packPaymasterData(data: PaymasterData): string;
+import { Hex } from "viem";
+import { PaymasterData, MetaTransaction } from "./types";
+export declare const PLACEHOLDER_SIG: `0x${string}`;
+type IntLike = Hex | bigint | string | number;
+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 {};

package/dist/cjs/util.js

@@ -4,22 +4,22 @@ exports.packGas = exports.PLACEHOLDER_SIG = void 0;
 exports.packSignature = packSignature;
 exports.packPaymasterData = packPaymasterData;
 exports.containsValue = containsValue;
-const ethers_1 = require("ethers");
-exports.PLACEHOLDER_SIG = ethers_1.ethers.solidityPacked(["uint48", "uint48"], [0, 0]);
-const packGas = (hi, lo) => ethers_1.ethers.solidityPacked(["uint128", "uint128"], [hi, lo]);
+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;
 function packSignature(signature, validFrom = 0, validTo = 0) {
-    return ethers_1.ethers.solidityPacked(["uint48", "uint48", "bytes"], [validFrom, validTo, signature]);
+    return (0, viem_1.encodePacked)(["uint48", "uint48", "bytes"], [validFrom, validTo, signature]);
 }
 function packPaymasterData(data) {
-    return data.paymaster
-        ? ethers_1.ethers.hexlify(ethers_1.ethers.concat([
+    return (data.paymaster
+        ? (0, viem_1.concatHex)([
             data.paymaster,
-            ethers_1.ethers.toBeHex(data.paymasterVerificationGasLimit || "0x", 16),
-            ethers_1.ethers.toBeHex(data.paymasterPostOpGasLimit || "0x", 16),
+            (0, viem_1.toHex)(BigInt(data.paymasterVerificationGasLimit || 0n), { size: 16 }),
+            (0, viem_1.toHex)(BigInt(data.paymasterPostOpGasLimit || 0n), { size: 16 }),
             data.paymasterData || "0x",
-        ]))
-        : "0x";
+        ])
+        : "0x");
 }
 function containsValue(transactions) {
     return transactions.some((tx) => tx.value !== "0");