near-safe 0.8.8 → 0.9.1

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,26 @@
+import { EvmMessage } from "near-ca";
+import { TransactionSerializable } from "viem";
+import { DecodedTxData, SafeEncodedSignRequest, UserOperation } 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;
+/**
+ * Represents different types of broadcastable messages
+ */
+export type BroadcastTarget = {
+    type: "evm";
+    transaction: TransactionSerializable;
+} | {
+    type: "bundler";
+    userOp: UserOperation;
+};
+/**
+ * Determines where and how an EVM message should be broadcast
+ * @param evmMessage - The message to be analyzed
+ * @returns Information about how to broadcast the message, or null if invalid
+ */
+export declare function determineBroadcastTarget(evmMessage: EvmMessage): BroadcastTarget | null;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTxData = decodeTxData;
+exports.determineBroadcastTarget = determineBroadcastTarget;
+const near_ca_1 = require("near-ca");
+const viem_1 = require("viem");
+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}`);
+}
+/**
+ * Determines where and how an EVM message should be broadcast
+ * @param evmMessage - The message to be analyzed
+ * @returns Information about how to broadcast the message, or null if invalid
+ */
+function determineBroadcastTarget(evmMessage) {
+    // Case 1: User Operation
+    if (typeof evmMessage === "string") {
+        try {
+            const parsed = (0, types_1.parseUserOperation)(evmMessage);
+            if (parsed) {
+                return {
+                    type: "bundler",
+                    userOp: parsed,
+                };
+            }
+        }
+        catch (error) {
+            console.warn("Failed to parse potential UserOperation:", error);
+        }
+    }
+    // Case 2: RLP Encoded EVM transaction
+    if ((0, near_ca_1.isRlpHex)(evmMessage)) {
+        return {
+            type: "evm",
+            transaction: (0, viem_1.parseTransaction)(evmMessage),
+        };
+    }
+    // Case 3: Serializable Transaction
+    if ((0, near_ca_1.isTransactionSerializable)(evmMessage)) {
+        return {
+            type: "evm",
+            transaction: evmMessage,
+        };
+    }
+    return null;
+}

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";
+export { Network, BaseTx, SignRequestData, populateTx, NetworkFields, signatureFromOutcome, signatureFromTxHash, requestRouter as mpcRequestRouter, EthTransactionParams, isRlpHex, } from "near-ca";

package/dist/cjs/index.js

@@ -14,17 +14,18 @@ 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.isRlpHex = 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);
+// TODO: Improve re-exports...
 var near_ca_1 = require("near-ca");
 Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return near_ca_1.Network; } });
 Object.defineProperty(exports, "populateTx", { enumerable: true, get: function () { return near_ca_1.populateTx; } });
 Object.defineProperty(exports, "signatureFromOutcome", { enumerable: true, get: function () { return near_ca_1.signatureFromOutcome; } });
 Object.defineProperty(exports, "signatureFromTxHash", { enumerable: true, get: function () { return near_ca_1.signatureFromTxHash; } });
 Object.defineProperty(exports, "mpcRequestRouter", { enumerable: true, get: function () { return near_ca_1.requestRouter; } });
+Object.defineProperty(exports, "isRlpHex", { enumerable: true, get: function () { return near_ca_1.isRlpHex; } });

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;