near-safe 0.8.8 → 0.9.0

package/dist/cjs/util.js

@@ -11,6 +11,7 @@ exports.saltNonceFromMessage = saltNonceFromMessage;
 exports.signatureFromTxHash = signatureFromTxHash;
 exports.raceToFirstResolve = raceToFirstResolve;
 exports.assertUnique = assertUnique;
+exports.userOpTransactionCost = userOpTransactionCost;
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
 const constants_1 = require("./constants");
@@ -31,13 +32,13 @@ function packPaymasterData(data) {
         : "0x");
 }
 function containsValue(transactions) {
-    return transactions.some((tx) => tx.value !== "0");
+    return transactions.some((tx) => BigInt(tx.value) !== 0n);
 }
 async function isContract(address, chainId) {
     return (await getClient(chainId).getCode({ address })) !== undefined;
 }
 function getClient(chainId) {
-    // TODO(bh2smith)
+    // TODO(bh2smith): Update defailt client URL in viem for sepolia.
     if (chainId === 11155111) {
         return (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)(constants_1.DEFAULT_SETUP_RPC) });
     }
@@ -144,3 +145,23 @@ function assertUnique(iterable, errorMessage = "The collection contains more tha
         throw new Error(errorMessage);
     }
 }
+function userOpTransactionCost(userOp) {
+    // Convert values from hex to decimal
+    const preVerificationGas = BigInt(userOp.preVerificationGas);
+    const verificationGasLimit = BigInt(userOp.verificationGasLimit);
+    const callGasLimit = BigInt(userOp.callGasLimit);
+    const paymasterVerificationGasLimit = BigInt(userOp.paymasterVerificationGasLimit || "0x0");
+    const paymasterPostOpGasLimit = BigInt(userOp.paymasterPostOpGasLimit || "0x0");
+    // Sum total gas
+    const totalGasUsed = preVerificationGas +
+        verificationGasLimit +
+        callGasLimit +
+        paymasterVerificationGasLimit +
+        paymasterPostOpGasLimit;
+    // Convert maxFeePerGas from hex to decimal
+    const maxFeePerGas = BigInt(userOp.maxFeePerGas);
+    // Calculate total cost in wei
+    const totalCostInWei = totalGasUsed * maxFeePerGas;
+    // Convert to Ether for a human-readable value
+    return totalCostInWei;
+}

package/dist/esm/decode/explain.d.ts

@@ -0,0 +1,38 @@
+import { DecodedTxData, SafeEncodedSignRequest } from "../types";
+/**
+ * Explain a Safe Signature Request.
+ * @param signRequest - The Safe Signature Request to explain.
+ * @returns The decoded transaction data as stringified JSON or null if there was an error.
+ */
+export declare function explainSignRequest(signRequest: SafeEncodedSignRequest): Promise<string>;
+/**
+ * Represents a parameter in a decoded contract call.
+ */
+interface DecodedParameter {
+    /** The parameter name from the contract ABI */
+    name: string;
+    /** The parameter type (e.g., 'address', 'uint256') */
+    type: string;
+    /** The actual value of the parameter */
+    value: string;
+}
+/**
+ * Represents a successful response from the Safe transaction decoder.
+ */
+interface FunctionSignature {
+    /** The name of the contract method that was called */
+    method: string;
+    /** Array of decoded parameters from the function call */
+    parameters: DecodedParameter[];
+}
+/**
+ * Decode a transaction using the Safe Decoder API. According to this spec:
+ * https://safe-transaction-sepolia.safe.global/#/data-decoder/data_decoder_create
+ * @param data - The transaction data to decode.
+ * @param to - The address of the contract that was called.
+ * @param chainId - The chain ID of the transaction.
+ * @returns The decoded transaction data or null if there was an error.
+ */
+export declare function safeDecodeTx(data: string, to: string, chainId: number): Promise<FunctionSignature | null>;
+export declare const formatEvmData: (decodedEvmData: DecodedTxData, functionSignatures?: (FunctionSignature | null)[]) => string;
+export {};

package/dist/esm/decode/explain.js

@@ -0,0 +1,91 @@
+import { Network } from "near-ca";
+import { decodeTxData } from ".";
+/**
+ * Explain a Safe Signature Request.
+ * @param signRequest - The Safe Signature Request to explain.
+ * @returns The decoded transaction data as stringified JSON or null if there was an error.
+ */
+export async function explainSignRequest(signRequest) {
+    // Decode the Signature Request
+    const decodedEvmData = decodeTxData(signRequest);
+    // Decode the function signatures
+    const functionSignatures = await Promise.all(decodedEvmData.transactions.map((tx) => safeDecodeTx(tx.data, tx.to, decodedEvmData.chainId)));
+    // Format the decoded data
+    return formatEvmData(decodedEvmData, functionSignatures);
+}
+const SAFE_NETWORKS = {
+    1: "mainnet", // Ethereum Mainnet
+    10: "optimism", // Optimism Mainnet
+    56: "binance", // Binance Smart Chain Mainnet
+    97: "bsc-testnet", // Binance Smart Chain Testnet
+    100: "gnosis-chain", // Gnosis Chain (formerly xDAI)
+    137: "polygon", // Polygon Mainnet
+    250: "fantom", // Fantom Mainnet
+    288: "boba", // Boba Network Mainnet
+    1284: "moonbeam", // Moonbeam (Polkadot)
+    1285: "moonriver", // Moonriver (Kusama)
+    4002: "fantom-testnet", // Fantom Testnet
+    42161: "arbitrum", // Arbitrum One Mainnet
+    43113: "avalanche-fuji", // Avalanche Fuji Testnet
+    43114: "avalanche", // Avalanche Mainnet
+    80001: "polygon-mumbai", // Polygon Mumbai Testnet
+    8453: "base", // Base Mainnet
+    11155111: "sepolia", // Sepolia Testnet
+    1666600000: "harmony", // Harmony Mainnet
+    1666700000: "harmony-testnet", // Harmony Testnet
+    1313161554: "aurora", // Aurora Mainnet (NEAR)
+    1313161555: "aurora-testnet", // Aurora Testnet (NEAR)
+};
+/**
+ * Decode a transaction using the Safe Decoder API. According to this spec:
+ * https://safe-transaction-sepolia.safe.global/#/data-decoder/data_decoder_create
+ * @param data - The transaction data to decode.
+ * @param to - The address of the contract that was called.
+ * @param chainId - The chain ID of the transaction.
+ * @returns The decoded transaction data or null if there was an error.
+ */
+export async function safeDecodeTx(data, to, chainId) {
+    try {
+        const network = SAFE_NETWORKS[chainId] || SAFE_NETWORKS[1];
+        const response = await fetch(`https://safe-transaction-${network}.safe.global/api/v1/data-decoder/`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                accept: "application/json",
+            },
+            body: JSON.stringify({ data, to }),
+        });
+        // Handle different response status codes
+        if (response.status === 404) {
+            console.warn("Cannot find function selector to decode data");
+            return null;
+        }
+        if (response.status === 422) {
+            const errorData = (await response.json());
+            console.error("Invalid data:", errorData.message, errorData.arguments);
+            return null;
+        }
+        if (!response.ok) {
+            console.error(`Unexpected response status: ${response.status}`);
+            return null;
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Error decoding transaction:", message);
+        return null;
+    }
+}
+export const formatEvmData = (decodedEvmData, functionSignatures = []) => {
+    const formatted = {
+        ...decodedEvmData,
+        network: Network.fromChainId(decodedEvmData.chainId).name,
+        functionSignatures,
+    };
+    return JSON.stringify(formatted, bigIntReplacer, 2);
+};
+/**
+ * Replaces bigint values with their string representation.
+ */
+const bigIntReplacer = (_, value) => typeof value === "bigint" ? value.toString() : value;

package/dist/esm/decode/index.d.ts

@@ -1,8 +1,2 @@
-import { DecodedTxData, SafeEncodedSignRequest } from "../types";
-/**
- * Decodes transaction data for a given EVM transaction and extracts relevant details.
- *
- * @param {EvmTransactionData} data - The raw transaction data to be decoded.
- * @returns {DecodedTxData} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
- */
-export declare function decodeTxData({ evmMessage, chainId, }: Omit<SafeEncodedSignRequest, "hashToSign">): DecodedTxData;
+export * from "./explain";
+export * from "./sign-request";

package/dist/esm/decode/index.js

@@ -1,49 +1,2 @@
-import { isRlpHex, isTransactionSerializable } from "../lib/safe-message";
-import { decodeRlpHex, decodeTransactionSerializable, decodeTypedData, decodeUserOperation, } from "./util";
-/**
- * Decodes transaction data for a given EVM transaction and extracts relevant details.
- *
- * @param {EvmTransactionData} data - The raw transaction data to be decoded.
- * @returns {DecodedTxData} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
- */
-export function decodeTxData({ evmMessage, chainId, }) {
-    const data = evmMessage;
-    if (isRlpHex(evmMessage)) {
-        return decodeRlpHex(chainId, evmMessage);
-    }
-    if (isTransactionSerializable(data)) {
-        return decodeTransactionSerializable(chainId, data);
-    }
-    if (typeof data !== "string") {
-        return decodeTypedData(chainId, data);
-    }
-    try {
-        // Stringified UserOperation.
-        const userOp = JSON.parse(data);
-        return decodeUserOperation(chainId, userOp);
-    }
-    catch (error) {
-        if (error instanceof SyntaxError) {
-            // Raw message string.
-            return {
-                chainId,
-                costEstimate: "0",
-                transactions: [],
-                message: data,
-            };
-        }
-        else {
-            // TODO: This shouldn't happen anymore and can probably be reverted.
-            // We keep it here now, because near-ca might not have adapted its router.
-            console.warn("Failed UserOp Parsing, try TypedData Parsing", error);
-            try {
-                const typedData = JSON.parse(data);
-                return decodeTypedData(chainId, typedData);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`decodeTxData: Unexpected error - ${message}`);
-            }
-        }
-    }
-}
+export * from "./explain";
+export * from "./sign-request";

package/dist/esm/decode/sign-request.d.ts

@@ -0,0 +1,8 @@
+import { DecodedTxData, SafeEncodedSignRequest } from "../types";
+/**
+ * Decodes transaction data for a given EVM transaction and extracts relevant details.
+ *
+ * @param {EvmTransactionData} data - The raw transaction data to be decoded.
+ * @returns {DecodedTxData} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
+ */
+export declare function decodeTxData({ evmMessage, chainId, }: Omit<SafeEncodedSignRequest, "hashToSign">): DecodedTxData;

package/dist/esm/decode/sign-request.js

@@ -0,0 +1,41 @@
+import { isRlpHex, isTransactionSerializable } from "near-ca";
+import { parseEip712TypedData, parseUserOperation, } from "../types";
+import { decodeRlpHex, decodeTransactionSerializable, decodeTypedData, decodeUserOperation, } from "./util";
+/**
+ * Decodes transaction data for a given EVM transaction and extracts relevant details.
+ *
+ * @param {EvmTransactionData} data - The raw transaction data to be decoded.
+ * @returns {DecodedTxData} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
+ */
+export function decodeTxData({ evmMessage, chainId, }) {
+    const data = evmMessage;
+    if (isRlpHex(evmMessage)) {
+        return decodeRlpHex(chainId, evmMessage);
+    }
+    if (isTransactionSerializable(data)) {
+        return decodeTransactionSerializable(chainId, data);
+    }
+    const parsedTypedData = parseEip712TypedData(data);
+    if (parsedTypedData) {
+        return decodeTypedData(chainId, parsedTypedData);
+    }
+    const userOp = parseUserOperation(data);
+    if (userOp) {
+        return decodeUserOperation(chainId, userOp);
+    }
+    // At this point we are certain that the data is a string.
+    // Typescript would disagree here because of the EIP712TypedData possibility that remains.
+    // However this is captured (indirectly) by parseEip712TypedData above.
+    // We check now if its a string and return a reasonable default (for the case of a raw message).
+    if (typeof data === "string") {
+        return {
+            chainId,
+            costEstimate: "0",
+            transactions: [],
+            message: data,
+        };
+    }
+    // Otherwise we have no idea what the data is and we throw.
+    console.warn("Unrecognized txData format,", chainId, data);
+    throw new Error(`decodeTxData: Invalid or unsupported message format ${data}`);
+}

package/dist/esm/decode/util.d.ts

@@ -5,13 +5,3 @@ export declare function decodeTransactionSerializable(chainId: number, tx: Trans
 export declare function decodeRlpHex(chainId: number, tx: Hex): DecodedTxData;
 export declare function decodeTypedData(chainId: number, data: EIP712TypedData): DecodedTxData;
 export declare function decodeUserOperation(chainId: number, userOp: UserOperation): DecodedTxData;
-export declare enum OperationType {
-    Call = 0,
-    DelegateCall = 1
-}
-export interface MetaTransaction {
-    readonly to: string;
-    readonly value: string;
-    readonly data: string;
-    readonly operation?: OperationType;
-}

package/dist/esm/index.d.ts

@@ -2,6 +2,6 @@ export * from "./near-safe";
 export * from "./types";
 export * from "./util";
 export * from "./constants";
-export { decodeTxData } from "./decode";
+export * from "./decode";
 export * from "./lib/safe-message";
 export { Network, BaseTx, SignRequestData, populateTx, NetworkFields, signatureFromOutcome, signatureFromTxHash, requestRouter as mpcRequestRouter, EthTransactionParams, } from "near-ca";

package/dist/esm/index.js

@@ -2,6 +2,6 @@ export * from "./near-safe";
 export * from "./types";
 export * from "./util";
 export * from "./constants";
-export { decodeTxData } from "./decode";
+export * from "./decode";
 export * from "./lib/safe-message";
 export { Network, populateTx, signatureFromOutcome, signatureFromTxHash, requestRouter as mpcRequestRouter, } from "near-ca";

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

@@ -1,5 +1,5 @@
 import { Address, Hash, PublicClient, Transport } from "viem";
-import { GasPrices, PaymasterData, SponsorshipPolicyData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+import { GasPrices, PaymasterData, SponsorshipPolicyData, UnsignedUserOperation, UserOperation, UserOperationGas, UserOperationReceipt } from "../types";
 type SponsorshipPolicy = {
     sponsorshipPolicyId: string;
 };
@@ -9,6 +9,11 @@ type BundlerRpcSchema = [
         Parameters: [UnsignedUserOperation, Address, SponsorshipPolicy];
         ReturnType: PaymasterData;
     },
+    {
+        Method: "eth_estimateUserOperationGas";
+        Parameters: [UnsignedUserOperation, Address];
+        ReturnType: UserOperationGas;
+    },
     {
         Method: "eth_sendUserOperation";
         Parameters: [UserOperation, Address];
@@ -31,7 +36,7 @@ export declare class Erc4337Bundler {
     apiKey: string;
     chainId: number;
     constructor(entryPointAddress: Address, apiKey: string, chainId: number);
-    getPaymasterData(rawUserOp: UnsignedUserOperation, safeNotDeployed: boolean, sponsorshipPolicy?: string): Promise<PaymasterData>;
+    getPaymasterData(rawUserOp: UnsignedUserOperation, sponsorshipPolicy?: string): Promise<PaymasterData>;
     sendUserOperation(userOp: UserOperation): Promise<Hash>;
     getGasPrice(): Promise<GasPrices>;
     getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;

package/dist/esm/lib/bundler.js

@@ -1,4 +1,4 @@
-import { createPublicClient, http, rpcSchema, toHex, RpcError, HttpRequestError, } from "viem";
+import { createPublicClient, http, rpcSchema, RpcError, HttpRequestError, } from "viem";
 import { PLACEHOLDER_SIG } from "../util";
 function bundlerUrl(chainId, apikey) {
     return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${apikey}`;
@@ -17,20 +17,24 @@ export class Erc4337Bundler {
             rpcSchema: rpcSchema(),
         });
     }
-    async getPaymasterData(rawUserOp, safeNotDeployed, sponsorshipPolicy) {
-        // TODO: Keep this option out of the bundler
+    async getPaymasterData(rawUserOp, sponsorshipPolicy) {
+        const userOp = { ...rawUserOp, signature: PLACEHOLDER_SIG };
         if (sponsorshipPolicy) {
             console.log("Requesting paymaster data...");
             return handleRequest(() => this.client.request({
                 method: "pm_sponsorUserOperation",
                 params: [
-                    { ...rawUserOp, signature: PLACEHOLDER_SIG },
+                    userOp,
                     this.entryPointAddress,
                     { sponsorshipPolicyId: sponsorshipPolicy },
                 ],
             }));
         }
-        return defaultPaymasterData(safeNotDeployed);
+        console.log("Estimating user operation gas...");
+        return handleRequest(() => this.client.request({
+            method: "eth_estimateUserOperationGas",
+            params: [userOp, this.entryPointAddress],
+        }));
     }
     async sendUserOperation(userOp) {
         return handleRequest(() => this.client.request({
@@ -93,14 +97,6 @@ async function handleRequest(clientMethod) {
         throw new Error(`Bundler Request: ${message}`);
     }
 }
-// TODO(bh2smith) Should probably get reasonable estimates here:
-const defaultPaymasterData = (safeNotDeployed) => {
-    return {
-        verificationGasLimit: toHex(safeNotDeployed ? 500000 : 100000),
-        callGasLimit: toHex(100000),
-        preVerificationGas: toHex(100000),
-    };
-};
 export function stripApiKey(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.replace(/(apikey=)[^\s&]+/, "$1***");

package/dist/esm/lib/safe-message.d.ts

@@ -1,6 +1,6 @@
 import { type SafeInfo } from "@safe-global/safe-gateway-typescript-sdk";
 import { EIP712TypedData } from "near-ca";
-import { Hash, Hex, TransactionSerializable } from "viem";
+import { Hash } from "viem";
 export type DecodedSafeMessage = {
     decodedMessage: string | EIP712TypedData;
     safeMessageMessage: string;
@@ -20,5 +20,3 @@ export type MinimalSafeInfo = Pick<SafeInfo, "address" | "version" | "chainId">;
  * }`
  */
 export declare function decodeSafeMessage(message: string | EIP712TypedData, safe: MinimalSafeInfo): DecodedSafeMessage;
-export declare function isTransactionSerializable(data: unknown): data is TransactionSerializable;
-export declare function isRlpHex(data: unknown): data is Hex;

package/dist/esm/lib/safe-message.js

@@ -1,5 +1,5 @@
 import { gte } from "semver";
-import { fromHex, hashMessage, hashTypedData, isHex, parseTransaction, serializeTransaction, } from "viem";
+import { fromHex, hashMessage, hashTypedData, isHex, } from "viem";
 /*
  * From v1.3.0, EIP-1271 support was moved to the CompatibilityFallbackHandler.
  * Also 1.3.0 introduces the chainId in the domain part of the SafeMessage
@@ -79,33 +79,5 @@ export function decodeSafeMessage(message, safe) {
         safeMessageHash: generateSafeMessageHash(safe, decodedMessage),
     };
 }
-// const isEIP712TypedData = (obj: any): obj is EIP712TypedData => {
-//   return (
-//     typeof obj === "object" &&
-//     obj != null &&
-//     "domain" in obj &&
-//     "types" in obj &&
-//     "message" in obj
-//   );
-// };
 // export const isBlindSigningPayload = (obj: EIP712TypedData | string): boolean =>
 //   !isEIP712TypedData(obj) && isHash(obj);
-// Cheeky attempt to serialize. return true if successful!
-export function isTransactionSerializable(data) {
-    try {
-        serializeTransaction(data);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-export function isRlpHex(data) {
-    try {
-        parseTransaction(data);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}

package/dist/esm/near-safe.js

@@ -103,7 +103,7 @@ export class NearSafe {
         // Build Singular MetaTransaction for Multisend from transaction list.
         const tx = transactions.length > 1 ? encodeMulti(transactions) : transactions[0];
         const rawUserOp = await this.safePack.buildUserOp(nonce, tx, this.address, gasFees.fast, this.setup, !safeDeployed, this.safeSaltNonce);
-        const paymasterData = await bundler.getPaymasterData(rawUserOp, !safeDeployed, sponsorshipPolicy);
+        const paymasterData = await bundler.getPaymasterData(rawUserOp, sponsorshipPolicy);
         const unsignedUserOp = { ...rawUserOp, ...paymasterData };
         return unsignedUserOp;
     }
@@ -239,7 +239,7 @@ export class NearSafe {
     async removeOwnerTx(chainId, address) {
         return {
             to: this.address,
-            value: "0",
+            value: "0x00",
             data: await this.safePack.removeOwnerData(chainId, this.address, address),
         };
     }

package/dist/esm/types/guards.d.ts

@@ -0,0 +1,6 @@
+import { EIP712TypedData } from "near-ca";
+import { UserOperation } from ".";
+export declare const isUserOperation: (data: unknown) => data is UserOperation;
+export declare const parseWithTypeGuard: <T>(data: unknown, typeGuard: (value: unknown) => value is T) => T | null;
+export declare const parseUserOperation: (data: unknown) => UserOperation | null;
+export declare const parseEip712TypedData: (data: unknown) => EIP712TypedData | null;

package/dist/esm/types/guards.js

@@ -0,0 +1,83 @@
+import { isEIP712TypedData } from "near-ca";
+import { isAddress, isHex } from "viem";
+export const isUserOperation = (data) => {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const candidate = data;
+    // Required fields
+    const hasRequiredFields = "sender" in candidate &&
+        "nonce" in candidate &&
+        "callData" in candidate &&
+        "maxPriorityFeePerGas" in candidate &&
+        "maxFeePerGas" in candidate &&
+        "verificationGasLimit" in candidate &&
+        "callGasLimit" in candidate &&
+        "preVerificationGas" in candidate;
+    if (!hasRequiredFields)
+        return false;
+    // Type checks for required fields
+    const hasValidRequiredTypes = typeof candidate.sender === "string" &&
+        isAddress(candidate.sender) &&
+        typeof candidate.nonce === "string" &&
+        isHex(candidate.callData) &&
+        isHex(candidate.maxPriorityFeePerGas) &&
+        isHex(candidate.maxFeePerGas) &&
+        isHex(candidate.verificationGasLimit) &&
+        isHex(candidate.callGasLimit) &&
+        isHex(candidate.preVerificationGas);
+    if (!hasValidRequiredTypes)
+        return false;
+    // Optional fields type checks
+    if ("factory" in candidate && candidate.factory !== undefined) {
+        if (typeof candidate.factory !== "string" || !isAddress(candidate.factory))
+            return false;
+    }
+    if ("factoryData" in candidate && candidate.factoryData !== undefined) {
+        if (!isHex(candidate.factoryData))
+            return false;
+    }
+    if ("signature" in candidate && candidate.signature !== undefined) {
+        if (!isHex(candidate.signature))
+            return false;
+    }
+    if ("paymaster" in candidate && candidate.paymaster !== undefined) {
+        if (typeof candidate.paymaster !== "string" ||
+            !isAddress(candidate.paymaster))
+            return false;
+    }
+    if ("paymasterData" in candidate && candidate.paymasterData !== undefined) {
+        if (!isHex(candidate.paymasterData))
+            return false;
+    }
+    if ("paymasterVerificationGasLimit" in candidate &&
+        candidate.paymasterVerificationGasLimit !== undefined) {
+        if (!isHex(candidate.paymasterVerificationGasLimit))
+            return false;
+    }
+    if ("paymasterPostOpGasLimit" in candidate &&
+        candidate.paymasterPostOpGasLimit !== undefined) {
+        if (!isHex(candidate.paymasterPostOpGasLimit))
+            return false;
+    }
+    return true;
+};
+export const parseWithTypeGuard = (data, typeGuard) => {
+    // Case 1: Already the correct type
+    if (typeGuard(data)) {
+        return data;
+    }
+    // Case 2: Stringified data
+    if (typeof data === "string") {
+        try {
+            const parsed = JSON.parse(data);
+            return typeGuard(parsed) ? parsed : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    // Neither valid type nor valid stringified type
+    return null;
+};
+export const parseUserOperation = (data) => parseWithTypeGuard(data, isUserOperation);
+export const parseEip712TypedData = (data) => parseWithTypeGuard(data, isEIP712TypedData);

package/dist/esm/{types.d.ts → types/index.d.ts}

@@ -1,5 +1,6 @@
 import { EIP712TypedData, EncodedSignRequest, FunctionCallTransaction, SignArgs } from "near-ca";
 import { Address, Hex, ParseAbi } from "viem";
+export * from "./guards";
 /**
  * Represents a collection of Safe contract deployments, each with its own address and ABI.
  */
@@ -46,24 +47,20 @@ export interface UnsignedUserOperation {
 /**
  * Supported representation of a user operation for EntryPoint version 0.7, including gas limits and signature.
  */
-export interface UserOperation extends UnsignedUserOperation {
-    /** The gas limit for verification of the operation. */
-    verificationGasLimit: Hex;
-    /** The gas limit for the execution of the operation call. */
-    callGasLimit: Hex;
-    /** The gas used before verification begins. */
-    preVerificationGas: Hex;
+export interface UserOperation extends UnsignedUserOperation, PaymasterData {
     /** Optional signature for the user operation. */
     signature?: Hex;
 }
 /**
  * Represents additional paymaster-related data for a user operation.
  */
-export interface PaymasterData {
+export interface PaymasterData extends UserOperationGas {
     /** Optional paymaster address responsible for covering gas costs. */
     paymaster?: Address;
     /** Optional additional data required by the paymaster. */
     paymasterData?: Hex;
+}
+export interface UserOperationGas {
     /** The gas limit for paymaster verification. */
     paymasterVerificationGasLimit?: Hex;
     /** The gas limit for paymaster post-operation execution. */
@@ -270,4 +267,3 @@ export interface SpendingLimit {
 export interface ChainIds {
     allowlist: number[];
 }
-export {};

package/dist/esm/{types.js → types/index.js}

@@ -1,3 +1,4 @@
+export * from "./guards";
 /**
  * Enum representing the type of operation in a meta-transaction.
  */

package/dist/esm/util.d.ts

@@ -1,6 +1,6 @@
 import { SessionRequestParams } from "near-ca";
 import { Address, Hex, PublicClient } from "viem";
-import { PaymasterData, MetaTransaction } from "./types";
+import { PaymasterData, MetaTransaction, UserOperation } from "./types";
 export declare const PLACEHOLDER_SIG: `0x${string}`;
 type IntLike = Hex | bigint | string | number;
 export declare const packGas: (hi: IntLike, lo: IntLike) => string;
@@ -38,4 +38,5 @@ export declare function signatureFromTxHash(txHash: string, accountId?: string):
  */
 export declare function raceToFirstResolve<T>(promises: Promise<T>[]): Promise<T>;
 export declare function assertUnique<T>(iterable: Iterable<T>, errorMessage?: string): void;
+export declare function userOpTransactionCost(userOp: UserOperation): bigint;
 export {};