near-safe 0.1.1 → 0.2.0

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

@@ -1,9 +1,12 @@
 import { ethers } from "ethers";
-import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types.js";
 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,19 +1,29 @@
 "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 util_1 = require("../util");
+const util_js_1 = require("../util.js");
+const viem_1 = require("viem");
+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
         if (usePaymaster) {
             console.log("Requesting paymaster data...");
             const data = this.provider.send("pm_sponsorUserOperation", [
-                { ...rawUserOp, signature: util_1.PLACEHOLDER_SIG },
+                { ...rawUserOp, signature: util_js_1.PLACEHOLDER_SIG },
                 this.entryPointAddress,
             ]);
             return data;
@@ -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/safe.d.ts

@@ -1,6 +1,7 @@
 import { ethers } from "ethers";
 import { GasPrice, UnsignedUserOperation, UserOperation } from "../types";
 import { MetaTransaction } from "ethers-multisend";
+import { Address, Hash, Hex } from "viem";
 /**
  * All contracts used in account creation & execution
  */
@@ -12,13 +13,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

@@ -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,37 @@
-import { ethers } from "ethers";
 import { NearEthAdapter, NearEthTxData, BaseTx } from "near-ca";
 import { Erc4337Bundler } from "./lib/bundler";
 import { UserOperation, UserOperationReceipt } from "./types";
 import { MetaTransaction } from "ethers-multisend";
 import { ContractSuite } from "./lib/safe";
+import { Address, Hash, Hex } from "viem";
 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;
         pimlicoKey: string;
         nearAdapter: NearEthAdapter;
         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>;
 }

package/dist/cjs/tx-manager.js

@@ -1,82 +1,67 @@
 "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 bundler_1 = require("./lib/bundler");
 const util_1 = require("./util");
-const near_1 = require("./lib/near");
 const ethers_multisend_1 = require("ethers-multisend");
 const safe_1 = require("./lib/safe");
 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 safePack = await 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 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 +82,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,12 +110,12 @@ 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;
     }
 }

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;

package/dist/cjs/util.d.ts

@@ -1,8 +1,10 @@
-import { ethers } from "ethers";
-import { PaymasterData } from "./types";
+import { PaymasterData } from "./types.js";
 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";
+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");

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

@@ -1,9 +1,12 @@
 import { ethers } from "ethers";
-import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types.js";
 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 { PLACEHOLDER_SIG } from "../util";
+import { PLACEHOLDER_SIG } from "../util.js";
+import { toHex } from "viem";
+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/safe.d.ts

@@ -1,6 +1,7 @@
 import { ethers } from "ethers";
 import { GasPrice, UnsignedUserOperation, UserOperation } from "../types";
 import { MetaTransaction } from "ethers-multisend";
+import { Address, Hash, Hex } from "viem";
 /**
  * All contracts used in account creation & execution
  */
@@ -12,13 +13,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

@@ -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,37 @@
-import { ethers } from "ethers";
 import { NearEthAdapter, NearEthTxData, BaseTx } from "near-ca";
 import { Erc4337Bundler } from "./lib/bundler";
 import { UserOperation, UserOperationReceipt } from "./types";
 import { MetaTransaction } from "ethers-multisend";
 import { ContractSuite } from "./lib/safe";
+import { Address, Hash, Hex } from "viem";
 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;
         pimlicoKey: string;
         nearAdapter: NearEthAdapter;
         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>;
 }

package/dist/esm/tx-manager.js

@@ -1,88 +1,72 @@
-import { ethers } from "ethers";
 import { Network } from "near-ca";
 import { Erc4337Bundler } from "./lib/bundler";
 import { packSignature } from "./util";
-import { getNearSignature } from "./lib/near";
 import { encodeMulti } from "ethers-multisend";
 import { ContractSuite } from "./lib/safe";
 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 safePack = await 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 +87,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 +115,12 @@ 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;
     }
 }

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;

package/dist/esm/util.d.ts

@@ -1,8 +1,10 @@
-import { ethers } from "ethers";
-import { PaymasterData } from "./types";
+import { PaymasterData } from "./types.js";
 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";
+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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -35,6 +35,7 @@
     "start": "yarn example",
     "example": "tsx examples/send-tx.ts",
     "lint": "eslint . --ignore-pattern dist/",
+    "test": "jest",
     "fmt": "prettier --write '{src,examples,tests}/**/*.{js,jsx,ts,tsx}'",
     "all": "yarn fmt && yarn lint && yarn build"
   },
@@ -44,16 +45,21 @@
     "ethers": "^6.13.1",
     "ethers-multisend": "^3.1.0",
     "near-api-js": "^5.0.0",
-    "near-ca": "^0.5.2"
+    "near-ca": "^0.5.2",
+    "viem": "^2.16.5",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "@types/node": "^22.3.0",
     "@types/yargs": "^17.0.32",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",
     "dotenv": "^16.4.5",
     "eslint": "^9.6.0",
+    "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"

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

@@ -1,3 +0,0 @@
-import { ethers } from "ethers";
-import { NearEthAdapter } from "near-ca";
-export declare function getNearSignature(adapter: NearEthAdapter, hash: ethers.BytesLike): Promise<string>;

package/dist/cjs/lib/near.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNearSignature = getNearSignature;
-const ethers_1 = require("ethers");
-async function getNearSignature(adapter, hash) {
-    const viemHash = typeof hash === "string" ? hash : hash;
-    // MPC Contract produces two possible signatures.
-    const signature = await adapter.sign(viemHash);
-    if (ethers_1.ethers.recoverAddress(hash, signature).toLocaleLowerCase() ===
-        adapter.address.toLocaleLowerCase()) {
-        return signature;
-    }
-    throw new Error("Invalid signature!");
-}

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

@@ -1,3 +0,0 @@
-import { ethers } from "ethers";
-import { NearEthAdapter } from "near-ca";
-export declare function getNearSignature(adapter: NearEthAdapter, hash: ethers.BytesLike): Promise<string>;

package/dist/esm/lib/near.js

@@ -1,11 +0,0 @@
-import { ethers } from "ethers";
-export async function getNearSignature(adapter, hash) {
-    const viemHash = typeof hash === "string" ? hash : hash;
-    // MPC Contract produces two possible signatures.
-    const signature = await adapter.sign(viemHash);
-    if (ethers.recoverAddress(hash, signature).toLocaleLowerCase() ===
-        adapter.address.toLocaleLowerCase()) {
-        return signature;
-    }
-    throw new Error("Invalid signature!");
-}