near-safe 0.8.8 → 0.9.0

package/dist/cjs/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/cjs/decode/explain.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatEvmData = void 0;
+exports.explainSignRequest = explainSignRequest;
+exports.safeDecodeTx = safeDecodeTx;
+const near_ca_1 = require("near-ca");
+const _1 = require(".");
+/**
+ * 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.
+ */
+async function explainSignRequest(signRequest) {
+    // Decode the Signature Request
+    const decodedEvmData = (0, _1.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 (0, exports.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.
+ */
+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;
+    }
+}
+const formatEvmData = (decodedEvmData, functionSignatures = []) => {
+    const formatted = {
+        ...decodedEvmData,
+        network: near_ca_1.Network.fromChainId(decodedEvmData.chainId).name,
+        functionSignatures,
+    };
+    return JSON.stringify(formatted, bigIntReplacer, 2);
+};
+exports.formatEvmData = formatEvmData;
+/**
+ * Replaces bigint values with their string representation.
+ */
+const bigIntReplacer = (_, value) => typeof value === "bigint" ? value.toString() : value;

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

@@ -1,52 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeTxData = decodeTxData;
-const safe_message_1 = require("../lib/safe-message");
-const util_1 = require("./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.
- */
-function decodeTxData({ evmMessage, chainId, }) {
-    const data = evmMessage;
-    if ((0, safe_message_1.isRlpHex)(evmMessage)) {
-        return (0, util_1.decodeRlpHex)(chainId, evmMessage);
-    }
-    if ((0, safe_message_1.isTransactionSerializable)(data)) {
-        return (0, util_1.decodeTransactionSerializable)(chainId, data);
-    }
-    if (typeof data !== "string") {
-        return (0, util_1.decodeTypedData)(chainId, data);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    try {
-        // Stringified UserOperation.
-        const userOp = JSON.parse(data);
-        return (0, util_1.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 (0, util_1.decodeTypedData)(chainId, typedData);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`decodeTxData: Unexpected error - ${message}`);
-            }
-        }
-    }
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./explain"), exports);
+__exportStar(require("./sign-request"), exports);

package/dist/cjs/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/cjs/decode/sign-request.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTxData = decodeTxData;
+const near_ca_1 = require("near-ca");
+const types_1 = require("../types");
+const util_1 = require("./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.
+ */
+function decodeTxData({ evmMessage, chainId, }) {
+    const data = evmMessage;
+    if ((0, near_ca_1.isRlpHex)(evmMessage)) {
+        return (0, util_1.decodeRlpHex)(chainId, evmMessage);
+    }
+    if ((0, near_ca_1.isTransactionSerializable)(data)) {
+        return (0, util_1.decodeTransactionSerializable)(chainId, data);
+    }
+    const parsedTypedData = (0, types_1.parseEip712TypedData)(data);
+    if (parsedTypedData) {
+        return (0, util_1.decodeTypedData)(chainId, parsedTypedData);
+    }
+    const userOp = (0, types_1.parseUserOperation)(data);
+    if (userOp) {
+        return (0, util_1.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/cjs/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/cjs/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/cjs/index.js

@@ -14,13 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mpcRequestRouter = exports.signatureFromTxHash = exports.signatureFromOutcome = exports.populateTx = exports.Network = exports.decodeTxData = void 0;
+exports.mpcRequestRouter = exports.signatureFromTxHash = exports.signatureFromOutcome = exports.populateTx = exports.Network = void 0;
 __exportStar(require("./near-safe"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./util"), exports);
 __exportStar(require("./constants"), exports);
-var decode_1 = require("./decode");
-Object.defineProperty(exports, "decodeTxData", { enumerable: true, get: function () { return decode_1.decodeTxData; } });
+__exportStar(require("./decode"), exports);
 __exportStar(require("./lib/safe-message"), exports);
 var near_ca_1 = require("near-ca");
 Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return near_ca_1.Network; } });

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

@@ -17,20 +17,24 @@ class Erc4337Bundler {
             rpcSchema: (0, viem_1.rpcSchema)(),
         });
     }
-    async getPaymasterData(rawUserOp, safeNotDeployed, sponsorshipPolicy) {
-        // TODO: Keep this option out of the bundler
+    async getPaymasterData(rawUserOp, sponsorshipPolicy) {
+        const userOp = { ...rawUserOp, signature: util_1.PLACEHOLDER_SIG };
         if (sponsorshipPolicy) {
             console.log("Requesting paymaster data...");
             return handleRequest(() => this.client.request({
                 method: "pm_sponsorUserOperation",
                 params: [
-                    { ...rawUserOp, signature: util_1.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({
@@ -94,14 +98,6 @@ async function handleRequest(clientMethod) {
         throw new Error(`Bundler Request: ${message}`);
     }
 }
-// TODO(bh2smith) Should probably get reasonable estimates here:
-const defaultPaymasterData = (safeNotDeployed) => {
-    return {
-        verificationGasLimit: (0, viem_1.toHex)(safeNotDeployed ? 500000 : 100000),
-        callGasLimit: (0, viem_1.toHex)(100000),
-        preVerificationGas: (0, viem_1.toHex)(100000),
-    };
-};
 function stripApiKey(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.replace(/(apikey=)[^\s&]+/, "$1***");

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

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeSafeMessage = decodeSafeMessage;
-exports.isTransactionSerializable = isTransactionSerializable;
-exports.isRlpHex = isRlpHex;
 const semver_1 = require("semver");
 const viem_1 = require("viem");
 /*
@@ -84,33 +82,5 @@ 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!
-function isTransactionSerializable(data) {
-    try {
-        (0, viem_1.serializeTransaction)(data);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-function isRlpHex(data) {
-    try {
-        (0, viem_1.parseTransaction)(data);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}

package/dist/cjs/near-safe.js

@@ -100,7 +100,7 @@ class NearSafe {
         // Build Singular MetaTransaction for Multisend from transaction list.
         const tx = transactions.length > 1 ? (0, multisend_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;
     }
@@ -236,7 +236,7 @@ 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/cjs/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/cjs/types/guards.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEip712TypedData = exports.parseUserOperation = exports.parseWithTypeGuard = exports.isUserOperation = void 0;
+const near_ca_1 = require("near-ca");
+const viem_1 = require("viem");
+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" &&
+        (0, viem_1.isAddress)(candidate.sender) &&
+        typeof candidate.nonce === "string" &&
+        (0, viem_1.isHex)(candidate.callData) &&
+        (0, viem_1.isHex)(candidate.maxPriorityFeePerGas) &&
+        (0, viem_1.isHex)(candidate.maxFeePerGas) &&
+        (0, viem_1.isHex)(candidate.verificationGasLimit) &&
+        (0, viem_1.isHex)(candidate.callGasLimit) &&
+        (0, viem_1.isHex)(candidate.preVerificationGas);
+    if (!hasValidRequiredTypes)
+        return false;
+    // Optional fields type checks
+    if ("factory" in candidate && candidate.factory !== undefined) {
+        if (typeof candidate.factory !== "string" || !(0, viem_1.isAddress)(candidate.factory))
+            return false;
+    }
+    if ("factoryData" in candidate && candidate.factoryData !== undefined) {
+        if (!(0, viem_1.isHex)(candidate.factoryData))
+            return false;
+    }
+    if ("signature" in candidate && candidate.signature !== undefined) {
+        if (!(0, viem_1.isHex)(candidate.signature))
+            return false;
+    }
+    if ("paymaster" in candidate && candidate.paymaster !== undefined) {
+        if (typeof candidate.paymaster !== "string" ||
+            !(0, viem_1.isAddress)(candidate.paymaster))
+            return false;
+    }
+    if ("paymasterData" in candidate && candidate.paymasterData !== undefined) {
+        if (!(0, viem_1.isHex)(candidate.paymasterData))
+            return false;
+    }
+    if ("paymasterVerificationGasLimit" in candidate &&
+        candidate.paymasterVerificationGasLimit !== undefined) {
+        if (!(0, viem_1.isHex)(candidate.paymasterVerificationGasLimit))
+            return false;
+    }
+    if ("paymasterPostOpGasLimit" in candidate &&
+        candidate.paymasterPostOpGasLimit !== undefined) {
+        if (!(0, viem_1.isHex)(candidate.paymasterPostOpGasLimit))
+            return false;
+    }
+    return true;
+};
+exports.isUserOperation = isUserOperation;
+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;
+};
+exports.parseWithTypeGuard = parseWithTypeGuard;
+const parseUserOperation = (data) => (0, exports.parseWithTypeGuard)(data, exports.isUserOperation);
+exports.parseUserOperation = parseUserOperation;
+const parseEip712TypedData = (data) => (0, exports.parseWithTypeGuard)(data, near_ca_1.isEIP712TypedData);
+exports.parseEip712TypedData = parseEip712TypedData;

package/dist/cjs/{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/cjs/types/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationType = void 0;
+__exportStar(require("./guards"), exports);
+/**
+ * Enum representing the type of operation in a meta-transaction.
+ */
+var OperationType;
+(function (OperationType) {
+    /** Standard call operation (0). */
+    OperationType[OperationType["Call"] = 0] = "Call";
+    /** Delegate call operation (1). */
+    OperationType[OperationType["DelegateCall"] = 1] = "DelegateCall";
+})(OperationType || (exports.OperationType = OperationType = {}));

package/dist/cjs/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 {};