@mentaproject/core 0.5.12 → 0.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/core",
-  "version": "0.5.12",
+  "version": "0.5.15",
   "description": "Core library for menta packages, it includes all basic evm instances like Account, Transactions, Blocks etc...",
   "type": "module",
   "main": "dist/index.js",

package/src/actions/index.ts

@@ -1,12 +1,17 @@
 export * from "viem/actions";
 
 export {
-    sendTransaction, signMessage, signTypedData, writeContract
+  sendTransaction,
+  signMessage,
+  signTypedData,
+  writeContract,
 } from "permissionless/actions/smartAccount";
 
 /** Trace Actions */
 export { traceFilter } from "./traceFilter";
 export { traceTransaction } from "./traceTransaction";
+export { traceActions } from "./traceActions";
+export type { TraceActions } from "./traceActions";
 
 /** Block Range Actions */
-export { fetchByBlockRange } from "./fetchByBlockRange";
+export { fetchByBlockRange } from "./fetchByBlockRange";

package/src/actions/traceActions.ts

@@ -0,0 +1,25 @@
+import type { Chain, Client, Transport } from "viem";
+import type {
+  TraceFilterParameters,
+  TraceFilterReturnType,
+  TraceTransactionParameters,
+  TraceTransactionReturnType,
+} from "../types";
+import { traceFilter } from "./traceFilter";
+import { traceTransaction } from "./traceTransaction";
+
+export type TraceActions = {
+  traceFilter: (args: TraceFilterParameters) => Promise<TraceFilterReturnType>;
+  traceTransaction: (
+    args: TraceTransactionParameters,
+  ) => Promise<TraceTransactionReturnType>;
+};
+
+export function traceActions(): <TChain extends Chain | undefined>(
+  client: Client<Transport, TChain>,
+) => TraceActions {
+  return (client) => ({
+    traceFilter: (args) => traceFilter(client, args),
+    traceTransaction: (args) => traceTransaction(client, args),
+  });
+}

package/src/actions/traceFilter.ts

@@ -1,4 +1,5 @@
-import  type { TraceFilterParameters, TraceFilterReturnType, CoreClient, Hash } from "../types";
+import type { Client, Transport, Chain } from "viem";
+import type { TraceFilterParameters, TraceFilterReturnType } from "../types";
 
 /**
  * Calls the 'trace_filter' RPC method to retrieve execution traces
@@ -7,25 +8,30 @@ import  type { TraceFilterParameters, TraceFilterReturnType, CoreClient, Hash }
  * This function sends a JSON-RPC request to the Ethereum node (or EVM-compatible)
  * via the provided client object and returns the array of trace entries matching
  * the filters.
- * 
+ *
  * NOTE: This method relies on the non-standard 'trace_filter' method of the RPC.
  * It may not be supported by all nodes.
  *
- * @param client The CoreClient instance used to perform the RPC call.
+ * @param client The client instance used to perform the RPC call.
  * @param params The filtering parameters for the trace request (block range, addresses, etc.).
  * @returns A promise that returns an array of trace entries (GenericTraceEntry[])
  * that match the filtering criteria.
  */
-export async function traceFilter(client: CoreClient, params: TraceFilterParameters): Promise<TraceFilterReturnType> {
-    if (typeof params.fromAddress === "string") params.fromAddress = [params.fromAddress];
-    if (typeof params.toAddress === "string") params.toAddress = [params.toAddress];
-    
-    return await client.request<{
-        method: 'trace_filter',
-        Parameters: TraceFilterParameters[],
-        ReturnType: TraceFilterReturnType
-    }>({
-        method: 'trace_filter',
-        params: [params],
-    });
-}
+export async function traceFilter<TChain extends Chain | undefined>(
+  client: Client<Transport, TChain>,
+  params: TraceFilterParameters,
+): Promise<TraceFilterReturnType> {
+  if (typeof params.fromAddress === "string")
+    params.fromAddress = [params.fromAddress];
+  if (typeof params.toAddress === "string")
+    params.toAddress = [params.toAddress];
+
+  return await client.request<{
+    method: "trace_filter";
+    Parameters: TraceFilterParameters[];
+    ReturnType: TraceFilterReturnType;
+  }>({
+    method: "trace_filter",
+    params: [params],
+  });
+}

package/src/actions/traceTransaction.ts

@@ -1,4 +1,8 @@
-import  type { TraceTransactionParameters, TraceTransactionReturnType, CoreClient, Hash } from "../types";
+import type { Client, Transport, Chain } from "viem";
+import type {
+  TraceTransactionParameters,
+  TraceTransactionReturnType,
+} from "../types";
 
 /**
  * Calls the 'trace_transaction' RPC method to retrieve execution traces
@@ -7,22 +11,25 @@ import  type { TraceTransactionParameters, TraceTransactionReturnType, CoreClien
  * This function sends a JSON-RPC request to the Ethereum node (or EVM-compatible)
  * via the provided client object and returns the array of trace entries for
  * the specified transaction hash.
- * 
+ *
  * NOTE: This method relies on the non-standard 'trace_transaction' method of the RPC.
  * It may not be supported by all nodes.
- * 
- * @param client The CoreClient instance used to perform the RPC call.
+ *
+ * @param client The client instance used to perform the RPC call.
  * @param params The transaction hash for which to retrieve traces.
  * @returns A promise that returns an array of trace entries (GenericTraceEntry[])
  * for the specified transaction hash.
  */
-export async function traceTransaction(client: CoreClient, params: TraceTransactionParameters): Promise<TraceTransactionReturnType> {
-    return await client.request<{
-        method: 'trace_transaction',
-        Parameters: TraceTransactionParameters[],
-        ReturnType: TraceTransactionReturnType
-    }>({
-        method: 'trace_transaction',
-        params: [params],
-    });
-}
+export async function traceTransaction<TChain extends Chain | undefined>(
+  client: Client<Transport, TChain>,
+  params: TraceTransactionParameters,
+): Promise<TraceTransactionReturnType> {
+  return await client.request<{
+    method: "trace_transaction";
+    Parameters: TraceTransactionParameters[];
+    ReturnType: TraceTransactionReturnType;
+  }>({
+    method: "trace_transaction",
+    params: [params],
+  });
+}

package/src/clients/createMentaAccount.ts

@@ -2,17 +2,24 @@ import {
   PasskeyValidatorContractVersion,
   toPasskeyValidator,
 } from "@zerodev/passkey-validator";
-import { CoreClient, MentaAccountParams } from "../types";
+import { MentaAccountParams } from "../types";
 import { entryPoint07Address } from "../account-abstraction";
 import { toKernelSmartAccount } from "permissionless/accounts";
 import { createSmartAccountClient } from "permissionless";
 import { erc7579Actions } from "permissionless/actions/erc7579";
+import type {
+  Client,
+  Transport,
+  Chain,
+  JsonRpcAccount,
+  LocalAccount,
+} from "viem";
 
-export async function createMentaAccount(
-  coreClient: CoreClient,
+export async function createMentaAccount<TChain extends Chain | undefined>(
+  client: Client<Transport, TChain, JsonRpcAccount | LocalAccount | undefined>,
   params: MentaAccountParams,
 ) {
-  const validator = await toPasskeyValidator(coreClient, {
+  const validator = await toPasskeyValidator(client, {
     webAuthnKey: params.signer,
     entryPoint: {
       address: entryPoint07Address,
@@ -24,7 +31,7 @@ export async function createMentaAccount(
 
   const kernel = await toKernelSmartAccount({
     owners: [validator],
-    client: coreClient as any,
+    client: client,
   });
 
   return createSmartAccountClient({