near-safe 0.1.1 → 0.2.1

package/dist/esm/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/esm/index.js

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

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

@@ -1,11 +1,23 @@
+// TODO: Ethers dependency is only for Generic HTTP Provider
 import { ethers } from "ethers";
+import { toHex } 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;
     entryPointAddress;
-    constructor(bundlerUrl, entryPointAddress) {
+    apiKey;
+    chainId;
+    constructor(entryPointAddress, apiKey, chainId) {
         this.entryPointAddress = entryPointAddress;
-        this.provider = new ethers.JsonRpcProvider(bundlerUrl);
+        this.apiKey = apiKey;
+        this.chainId = chainId;
+        this.provider = new ethers.JsonRpcProvider(bundlerUrl(chainId, apiKey));
+    }
+    client(chainId) {
+        return new ethers.JsonRpcProvider(bundlerUrl(chainId, this.apiKey));
     }
     async getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed) {
         // TODO: Keep this option out of the bundler
@@ -51,8 +63,8 @@ export class Erc4337Bundler {
 // TODO(bh2smith) Should probably get reasonable estimates here:
 const defaultPaymasterData = (safeNotDeployed) => {
     return {
-        verificationGasLimit: ethers.toBeHex(safeNotDeployed ? 500000 : 100000),
-        callGasLimit: ethers.toBeHex(100000),
-        preVerificationGas: ethers.toBeHex(100000),
+        verificationGasLimit: toHex(safeNotDeployed ? 500000 : 100000),
+        callGasLimit: toHex(100000),
+        preVerificationGas: toHex(100000),
     };
 };

package/dist/esm/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/esm/lib/multisend.js

@@ -0,0 +1,36 @@
+import { encodeFunctionData, encodePacked, parseAbi, size, } from "viem";
+import { OperationType } from "../types";
+export const 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) => encodePacked(["uint8", "address", "uint256", "uint256", "bytes"], [
+    tx.operation || OperationType.Call,
+    tx.to,
+    BigInt(tx.value),
+    BigInt(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.
+export function encodeMulti(transactions, multiSendContractAddress = transactions.some((t) => t.operation === OperationType.DelegateCall)
+    ? MULTISEND_141
+    : MULTISEND_CALLONLY_141) {
+    const encodedTransactions = "0x" + transactions.map(encodeMetaTx).map(remove0x).join("");
+    return {
+        operation: OperationType.DelegateCall,
+        to: multiSendContractAddress,
+        value: "0x00",
+        data: encodeFunctionData({
+            abi: parseAbi(MULTI_SEND_ABI),
+            functionName: "multiSend",
+            args: [encodedTransactions],
+        }),
+    };
+}

package/dist/esm/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/esm/lib/safe.js

@@ -1,6 +1,6 @@
-import { ethers } from "ethers";
 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";
 /**
  * All contracts used in account creation & execution
@@ -20,16 +20,12 @@ export 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.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(getSafe4337ModuleDeployment);
@@ -76,16 +72,15 @@ export 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.solidityPacked(["address", "bytes"], [unsignedUserOp.factory, unsignedUserOp.factoryData])
+            initCode: factory
+                ? ethers.solidityPacked(["address", "bytes"], [factory, factoryData])
                 : "0x",
-            accountGasLimits: packGas(unsignedUserOp.verificationGasLimit, unsignedUserOp.callGasLimit),
-            gasFees: packGas(unsignedUserOp.maxPriorityFeePerGas, unsignedUserOp.maxFeePerGas),
+            accountGasLimits: packGas(verificationGasLimit, callGasLimit),
+            gasFees: packGas(maxPriorityFeePerGas, maxFeePerGas),
             paymasterAndData: packPaymasterData(unsignedUserOp),
             signature: PLACEHOLDER_SIG,
         });
@@ -118,8 +113,17 @@ export class 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.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.Contract(address, deployment.abi, provider);
 }

package/dist/esm/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/esm/tx-manager.js

@@ -1,88 +1,76 @@
-import { ethers } from "ethers";
-import { Network } from "near-ca";
+import { Network, setupAdapter, signatureFromOutcome, } from "near-ca";
+import { serializeSignature } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
-import { packSignature } from "./util";
-import { getNearSignature } from "./lib/near";
-import { encodeMulti } from "ethers-multisend";
+import { encodeMulti } from "./lib/multisend";
 import { ContractSuite } from "./lib/safe";
+import { packSignature } from "./util";
 export class TransactionManager {
-    provider;
     nearAdapter;
+    address;
+    entryPointAddress;
     safePack;
-    bundler;
     setup;
-    address;
-    chainId;
+    pimlicoKey;
     safeSaltNonce;
-    _safeNotDeployed;
-    constructor(provider, nearAdapter, safePack, bundler, setup, chainId, safeAddress, safeSaltNonce, safeNotDeployed) {
-        this.provider = provider;
+    deployedChains;
+    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.JsonRpcProvider(config.ethRpc);
-        const chainId = (await provider.getNetwork()).chainId;
-        const safePack = await ContractSuite.init(provider);
+        const { pimlicoKey } = config;
+        const [nearAdapter, safePack] = await Promise.all([
+            setupAdapter({ ...config }),
+            ContractSuite.init(),
+        ]);
         console.log(`Near Adapter: ${nearAdapter.nearAccountId()} <> ${nearAdapter.address}`);
-        const bundler = new 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: 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 = Network.fromChainId(chainId).client;
+        return await provider.getBalance({ address: this.address });
+    }
+    bundlerForChainId(chainId) {
+        return new 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 ? 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 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 getNearSignature(this.nearAdapter, safeOpHash);
+        const signature = await this.nearAdapter.sign(safeOpHash);
         return 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,
@@ -103,16 +91,27 @@ export 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 = 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,
@@ -120,12 +119,27 @@ export 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 = 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)}`);
+        }
+    }
 }

package/dist/esm/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/esm/types.js

@@ -1 +1,5 @@
-export {};
+export var OperationType;
+(function (OperationType) {
+    OperationType[OperationType["Call"] = 0] = "Call";
+    OperationType[OperationType["DelegateCall"] = 1] = "DelegateCall";
+})(OperationType || (OperationType = {}));

package/dist/esm/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/esm/util.js

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