near-safe 0.3.0 → 0.3.2

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

@@ -0,0 +1,22 @@
+import { type SafeInfo } from "@safe-global/safe-gateway-typescript-sdk";
+import { EIP712TypedData } from "near-ca";
+import { Hash } from "viem";
+export type DecodedSafeMessage = {
+    decodedMessage: string | EIP712TypedData;
+    safeMessageMessage: string;
+    safeMessageHash: Hash;
+};
+export type MinimalSafeInfo = Pick<SafeInfo, "address" | "version" | "chainId">;
+/**
+ * Returns the decoded message, the hash of the `message` and the hash of the `safeMessage`.
+ * The `safeMessageMessage` is the value inside the SafeMessage and the `safeMessageHash` gets signed if the connected wallet does not support `eth_signTypedData`.
+ *
+ * @param message message as string, UTF-8 encoded hex string or EIP-712 Typed Data
+ * @param safe SafeInfo of the opened Safe
+ * @returns `{
+ *   decodedMessage,
+ *   safeMessageMessage,
+ *   safeMessageHash
+ * }`
+ */
+export declare function decodeSafeMessage(message: string | EIP712TypedData, safe: MinimalSafeInfo): DecodedSafeMessage;

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSafeMessage = decodeSafeMessage;
+const semver_1 = require("semver");
+const viem_1 = require("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
+ */
+const EIP1271_FALLBACK_HANDLER_SUPPORTED_SAFE_VERSION = "1.3.0";
+const generateSafeMessageMessage = (message) => {
+    return typeof message === "string"
+        ? (0, viem_1.hashMessage)(message)
+        : (0, viem_1.hashTypedData)(message);
+};
+/**
+ * Generates `SafeMessage` typed data for EIP-712
+ * https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L12
+ * @param safe Safe which will sign the message
+ * @param message Message to sign
+ * @returns `SafeMessage` types for signing
+ */
+const generateSafeMessageTypedData = ({ version, chainId, address }, message) => {
+    if (!version) {
+        throw Error("Cannot create SafeMessage without version information");
+    }
+    const isHandledByFallbackHandler = (0, semver_1.gte)(version, EIP1271_FALLBACK_HANDLER_SUPPORTED_SAFE_VERSION);
+    const verifyingContract = address.value;
+    return {
+        domain: isHandledByFallbackHandler
+            ? {
+                chainId: Number(BigInt(chainId)),
+                verifyingContract,
+            }
+            : { verifyingContract },
+        types: {
+            SafeMessage: [{ name: "message", type: "bytes" }],
+        },
+        message: {
+            message: generateSafeMessageMessage(message),
+        },
+        primaryType: "SafeMessage",
+    };
+};
+const generateSafeMessageHash = (safe, message) => {
+    const typedData = generateSafeMessageTypedData(safe, message);
+    return (0, viem_1.hashTypedData)(typedData);
+};
+/**
+ * If message is a hex value and is Utf8 encoded string we decode it, else we return the raw message
+ * @param {string} message raw input message
+ * @returns {string}
+ */
+const getDecodedMessage = (message) => {
+    if ((0, viem_1.isHex)(message)) {
+        try {
+            return (0, viem_1.fromHex)(message, "string");
+        }
+        catch (e) {
+            // the hex string is not UTF8 encoding so return the raw message.
+        }
+    }
+    return message;
+};
+/**
+ * Returns the decoded message, the hash of the `message` and the hash of the `safeMessage`.
+ * The `safeMessageMessage` is the value inside the SafeMessage and the `safeMessageHash` gets signed if the connected wallet does not support `eth_signTypedData`.
+ *
+ * @param message message as string, UTF-8 encoded hex string or EIP-712 Typed Data
+ * @param safe SafeInfo of the opened Safe
+ * @returns `{
+ *   decodedMessage,
+ *   safeMessageMessage,
+ *   safeMessageHash
+ * }`
+ */
+function decodeSafeMessage(message, safe) {
+    const decodedMessage = typeof message === "string" ? getDecodedMessage(message) : message;
+    return {
+        decodedMessage,
+        safeMessageMessage: generateSafeMessageMessage(decodedMessage),
+        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);

package/dist/cjs/tx-manager.d.ts

@@ -1,9 +1,9 @@
 import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, NearEthTxData, BaseTx } from "near-ca";
+import { NearEthAdapter, SignRequestData } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
 import { ContractSuite } from "./lib/safe";
-import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
+import { EncodedTxData, MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
 export declare class TransactionManager {
     readonly nearAdapter: NearEthAdapter;
     readonly address: Address;
@@ -31,7 +31,7 @@ export declare class TransactionManager {
     }): Promise<UserOperation>;
     signTransaction(safeOpHash: Hex): Promise<Hex>;
     opHash(userOp: UserOperation): Promise<Hash>;
-    encodeSignRequest(tx: BaseTx): Promise<NearEthTxData>;
+    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
     executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
     safeDeployed(chainId: number): Promise<boolean>;
     addOwnerTx(address: Address): MetaTransaction;
@@ -40,4 +40,19 @@ export declare class TransactionManager {
         signature: Hex;
         receipt: UserOperationReceipt;
     }>;
+    /**
+     * Handles routing of signature requests based on the provided method, chain ID, and parameters.
+     *
+     * @async
+     * @function requestRouter
+     * @param {SignRequestData} params - An object containing the method, chain ID, and request parameters.
+     * @returns {Promise<{ evmMessage: string; payload: number[]; recoveryData: RecoveryData }>}
+     * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
+     *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
+     */
+    requestRouter({ method, chainId, params }: SignRequestData, usePaymaster: boolean): Promise<{
+        evmMessage: string;
+        payload: number[];
+        hash: Hash;
+    }>;
 }

package/dist/cjs/tx-manager.js

@@ -6,6 +6,7 @@ const viem_1 = require("viem");
 const bundler_1 = require("./lib/bundler");
 const multisend_1 = require("./lib/multisend");
 const safe_1 = require("./lib/safe");
+const safe_message_1 = require("./lib/safe-message");
 const util_1 = require("./util");
 class TransactionManager {
     constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce) {
@@ -66,27 +67,19 @@ class TransactionManager {
     async opHash(userOp) {
         return this.safePack.getOpHash(userOp);
     }
-    async encodeSignRequest(tx) {
-        const unsignedUserOp = await this.buildTransaction({
-            chainId: tx.chainId,
-            transactions: [
-                {
-                    to: tx.to,
-                    value: (tx.value || 0n).toString(),
-                    data: tx.data || "0x",
-                },
-            ],
-            usePaymaster: true,
-        });
-        const safeOpHash = (await this.opHash(unsignedUserOp));
-        const signRequest = await this.nearAdapter.encodeSignRequest({
-            method: "hash",
-            chainId: 0,
-            params: safeOpHash,
-        });
+    async encodeSignRequest(signRequest, usePaymaster) {
+        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, usePaymaster);
         return {
-            ...signRequest,
-            evmMessage: JSON.stringify(unsignedUserOp),
+            nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
+                path: this.nearAdapter.derivationPath,
+                payload,
+                key_version: 0,
+            }),
+            evmData: {
+                chainId: signRequest.chainId,
+                data: evmMessage,
+                hash,
+            },
         };
     }
     async executeTransaction(chainId, userOp) {
@@ -140,5 +133,61 @@ class TransactionManager {
             throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Handles routing of signature requests based on the provided method, chain ID, and parameters.
+     *
+     * @async
+     * @function requestRouter
+     * @param {SignRequestData} params - An object containing the method, chain ID, and request parameters.
+     * @returns {Promise<{ evmMessage: string; payload: number[]; recoveryData: RecoveryData }>}
+     * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
+     *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
+     */
+    async requestRouter({ method, chainId, params }, usePaymaster) {
+        const safeInfo = {
+            address: { value: this.address },
+            chainId: chainId.toString(),
+            // TODO: Should be able to read this from on chain.
+            version: "1.4.1+L2",
+        };
+        // TODO: We are provided with sender in the input, but also expect safeInfo.
+        // We should either confirm they agree or ignore one of the two.
+        switch (method) {
+            case "eth_signTypedData":
+            case "eth_signTypedData_v4":
+            case "eth_sign": {
+                const [_, messageOrData] = params;
+                const message = (0, safe_message_1.decodeSafeMessage)(messageOrData, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: (0, near_ca_1.toPayload)(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
+            }
+            case "personal_sign": {
+                const [messageHash, _] = params;
+                const message = (0, safe_message_1.decodeSafeMessage)(messageHash, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: (0, near_ca_1.toPayload)(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
+            }
+            case "eth_sendTransaction": {
+                const transactions = (0, util_1.metaTransactionsFromRequest)(params);
+                const userOp = await this.buildTransaction({
+                    chainId,
+                    transactions,
+                    usePaymaster,
+                });
+                const opHash = await this.opHash(userOp);
+                return {
+                    payload: (0, near_ca_1.toPayload)(opHash),
+                    evmMessage: JSON.stringify(userOp),
+                    hash: await this.opHash(userOp),
+                };
+            }
+        }
+    }
 }
 exports.TransactionManager = TransactionManager;

package/dist/cjs/types.d.ts

@@ -1,4 +1,5 @@
-import { Address, Hex } from "viem";
+import { FunctionCallTransaction, SignArgs } from "near-ca";
+import { Address, Hash, Hex, TransactionSerializable } from "viem";
 export interface UnsignedUserOperation {
     sender: Address;
     nonce: string;
@@ -89,4 +90,14 @@ export interface MetaTransaction {
     readonly data: string;
     readonly operation?: OperationType;
 }
+export interface EncodedTxData {
+    evmData: {
+        chainId: number;
+        data: string | TransactionSerializable;
+        hash: Hash;
+    };
+    nearPayload: FunctionCallTransaction<{
+        request: SignArgs;
+    }>;
+}
 export {};

package/dist/cjs/util.d.ts

@@ -1,3 +1,4 @@
+import { SessionRequestParams } from "near-ca";
 import { Address, Hex, PublicClient } from "viem";
 import { PaymasterData, MetaTransaction } from "./types";
 export declare const PLACEHOLDER_SIG: `0x${string}`;
@@ -8,4 +9,5 @@ export declare function packPaymasterData(data: PaymasterData): Hex;
 export declare function containsValue(transactions: MetaTransaction[]): boolean;
 export declare function isContract(address: Address, chainId: number): Promise<boolean>;
 export declare function getClient(chainId: number): PublicClient;
+export declare function metaTransactionsFromRequest(params: SessionRequestParams): MetaTransaction[];
 export {};

package/dist/cjs/util.js

@@ -6,8 +6,10 @@ exports.packPaymasterData = packPaymasterData;
 exports.containsValue = containsValue;
 exports.isContract = isContract;
 exports.getClient = getClient;
+exports.metaTransactionsFromRequest = metaTransactionsFromRequest;
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
+//
 exports.PLACEHOLDER_SIG = (0, viem_1.encodePacked)(["uint48", "uint48"], [0, 0]);
 const packGas = (hi, lo) => (0, viem_1.encodePacked)(["uint128", "uint128"], [BigInt(hi), BigInt(lo)]);
 exports.packGas = packGas;
@@ -33,3 +35,26 @@ async function isContract(address, chainId) {
 function getClient(chainId) {
     return near_ca_1.Network.fromChainId(chainId).client;
 }
+function metaTransactionsFromRequest(params) {
+    let transactions;
+    if ((0, viem_1.isHex)(params)) {
+        // If RLP hex is given, decode the transaction and build EthTransactionParams
+        const tx = (0, viem_1.parseTransaction)(params);
+        transactions = [
+            {
+                from: viem_1.zeroAddress, // TODO: This is a hack - but its unused.
+                to: tx.to,
+                value: tx.value ? (0, viem_1.toHex)(tx.value) : "0x00",
+                data: tx.data || "0x",
+            },
+        ];
+    }
+    else {
+        transactions = params;
+    }
+    return transactions.map((tx) => ({
+        to: tx.to,
+        value: tx.value || "0x00",
+        data: tx.data || "0x",
+    }));
+}

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

@@ -0,0 +1,22 @@
+import { type SafeInfo } from "@safe-global/safe-gateway-typescript-sdk";
+import { EIP712TypedData } from "near-ca";
+import { Hash } from "viem";
+export type DecodedSafeMessage = {
+    decodedMessage: string | EIP712TypedData;
+    safeMessageMessage: string;
+    safeMessageHash: Hash;
+};
+export type MinimalSafeInfo = Pick<SafeInfo, "address" | "version" | "chainId">;
+/**
+ * Returns the decoded message, the hash of the `message` and the hash of the `safeMessage`.
+ * The `safeMessageMessage` is the value inside the SafeMessage and the `safeMessageHash` gets signed if the connected wallet does not support `eth_signTypedData`.
+ *
+ * @param message message as string, UTF-8 encoded hex string or EIP-712 Typed Data
+ * @param safe SafeInfo of the opened Safe
+ * @returns `{
+ *   decodedMessage,
+ *   safeMessageMessage,
+ *   safeMessageHash
+ * }`
+ */
+export declare function decodeSafeMessage(message: string | EIP712TypedData, safe: MinimalSafeInfo): DecodedSafeMessage;

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

@@ -0,0 +1,92 @@
+import { gte } from "semver";
+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
+ */
+const EIP1271_FALLBACK_HANDLER_SUPPORTED_SAFE_VERSION = "1.3.0";
+const generateSafeMessageMessage = (message) => {
+    return typeof message === "string"
+        ? hashMessage(message)
+        : hashTypedData(message);
+};
+/**
+ * Generates `SafeMessage` typed data for EIP-712
+ * https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L12
+ * @param safe Safe which will sign the message
+ * @param message Message to sign
+ * @returns `SafeMessage` types for signing
+ */
+const generateSafeMessageTypedData = ({ version, chainId, address }, message) => {
+    if (!version) {
+        throw Error("Cannot create SafeMessage without version information");
+    }
+    const isHandledByFallbackHandler = gte(version, EIP1271_FALLBACK_HANDLER_SUPPORTED_SAFE_VERSION);
+    const verifyingContract = address.value;
+    return {
+        domain: isHandledByFallbackHandler
+            ? {
+                chainId: Number(BigInt(chainId)),
+                verifyingContract,
+            }
+            : { verifyingContract },
+        types: {
+            SafeMessage: [{ name: "message", type: "bytes" }],
+        },
+        message: {
+            message: generateSafeMessageMessage(message),
+        },
+        primaryType: "SafeMessage",
+    };
+};
+const generateSafeMessageHash = (safe, message) => {
+    const typedData = generateSafeMessageTypedData(safe, message);
+    return hashTypedData(typedData);
+};
+/**
+ * If message is a hex value and is Utf8 encoded string we decode it, else we return the raw message
+ * @param {string} message raw input message
+ * @returns {string}
+ */
+const getDecodedMessage = (message) => {
+    if (isHex(message)) {
+        try {
+            return fromHex(message, "string");
+        }
+        catch (e) {
+            // the hex string is not UTF8 encoding so return the raw message.
+        }
+    }
+    return message;
+};
+/**
+ * Returns the decoded message, the hash of the `message` and the hash of the `safeMessage`.
+ * The `safeMessageMessage` is the value inside the SafeMessage and the `safeMessageHash` gets signed if the connected wallet does not support `eth_signTypedData`.
+ *
+ * @param message message as string, UTF-8 encoded hex string or EIP-712 Typed Data
+ * @param safe SafeInfo of the opened Safe
+ * @returns `{
+ *   decodedMessage,
+ *   safeMessageMessage,
+ *   safeMessageHash
+ * }`
+ */
+export function decodeSafeMessage(message, safe) {
+    const decodedMessage = typeof message === "string" ? getDecodedMessage(message) : message;
+    return {
+        decodedMessage,
+        safeMessageMessage: generateSafeMessageMessage(decodedMessage),
+        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);

package/dist/esm/tx-manager.d.ts

@@ -1,9 +1,9 @@
 import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, NearEthTxData, BaseTx } from "near-ca";
+import { NearEthAdapter, SignRequestData } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
 import { ContractSuite } from "./lib/safe";
-import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
+import { EncodedTxData, MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
 export declare class TransactionManager {
     readonly nearAdapter: NearEthAdapter;
     readonly address: Address;
@@ -31,7 +31,7 @@ export declare class TransactionManager {
     }): Promise<UserOperation>;
     signTransaction(safeOpHash: Hex): Promise<Hex>;
     opHash(userOp: UserOperation): Promise<Hash>;
-    encodeSignRequest(tx: BaseTx): Promise<NearEthTxData>;
+    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
     executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
     safeDeployed(chainId: number): Promise<boolean>;
     addOwnerTx(address: Address): MetaTransaction;
@@ -40,4 +40,19 @@ export declare class TransactionManager {
         signature: Hex;
         receipt: UserOperationReceipt;
     }>;
+    /**
+     * Handles routing of signature requests based on the provided method, chain ID, and parameters.
+     *
+     * @async
+     * @function requestRouter
+     * @param {SignRequestData} params - An object containing the method, chain ID, and request parameters.
+     * @returns {Promise<{ evmMessage: string; payload: number[]; recoveryData: RecoveryData }>}
+     * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
+     *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
+     */
+    requestRouter({ method, chainId, params }: SignRequestData, usePaymaster: boolean): Promise<{
+        evmMessage: string;
+        payload: number[];
+        hash: Hash;
+    }>;
 }

package/dist/esm/tx-manager.js

@@ -1,9 +1,10 @@
-import { setupAdapter, signatureFromOutcome, } from "near-ca";
+import { setupAdapter, signatureFromOutcome, toPayload, } from "near-ca";
 import { serializeSignature } from "viem";
 import { Erc4337Bundler } from "./lib/bundler";
 import { encodeMulti } from "./lib/multisend";
 import { ContractSuite } from "./lib/safe";
-import { getClient, isContract, packSignature } from "./util";
+import { decodeSafeMessage } from "./lib/safe-message";
+import { getClient, isContract, metaTransactionsFromRequest, packSignature, } from "./util";
 export class TransactionManager {
     nearAdapter;
     address;
@@ -70,27 +71,19 @@ export class TransactionManager {
     async opHash(userOp) {
         return this.safePack.getOpHash(userOp);
     }
-    async encodeSignRequest(tx) {
-        const unsignedUserOp = await this.buildTransaction({
-            chainId: tx.chainId,
-            transactions: [
-                {
-                    to: tx.to,
-                    value: (tx.value || 0n).toString(),
-                    data: tx.data || "0x",
-                },
-            ],
-            usePaymaster: true,
-        });
-        const safeOpHash = (await this.opHash(unsignedUserOp));
-        const signRequest = await this.nearAdapter.encodeSignRequest({
-            method: "hash",
-            chainId: 0,
-            params: safeOpHash,
-        });
+    async encodeSignRequest(signRequest, usePaymaster) {
+        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, usePaymaster);
         return {
-            ...signRequest,
-            evmMessage: JSON.stringify(unsignedUserOp),
+            nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
+                path: this.nearAdapter.derivationPath,
+                payload,
+                key_version: 0,
+            }),
+            evmData: {
+                chainId: signRequest.chainId,
+                data: evmMessage,
+                hash,
+            },
         };
     }
     async executeTransaction(chainId, userOp) {
@@ -144,4 +137,60 @@ export class TransactionManager {
             throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Handles routing of signature requests based on the provided method, chain ID, and parameters.
+     *
+     * @async
+     * @function requestRouter
+     * @param {SignRequestData} params - An object containing the method, chain ID, and request parameters.
+     * @returns {Promise<{ evmMessage: string; payload: number[]; recoveryData: RecoveryData }>}
+     * - Returns a promise that resolves to an object containing the Ethereum Virtual Machine (EVM) message,
+     *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
+     */
+    async requestRouter({ method, chainId, params }, usePaymaster) {
+        const safeInfo = {
+            address: { value: this.address },
+            chainId: chainId.toString(),
+            // TODO: Should be able to read this from on chain.
+            version: "1.4.1+L2",
+        };
+        // TODO: We are provided with sender in the input, but also expect safeInfo.
+        // We should either confirm they agree or ignore one of the two.
+        switch (method) {
+            case "eth_signTypedData":
+            case "eth_signTypedData_v4":
+            case "eth_sign": {
+                const [_, messageOrData] = params;
+                const message = decodeSafeMessage(messageOrData, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: toPayload(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
+            }
+            case "personal_sign": {
+                const [messageHash, _] = params;
+                const message = decodeSafeMessage(messageHash, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: toPayload(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
+            }
+            case "eth_sendTransaction": {
+                const transactions = metaTransactionsFromRequest(params);
+                const userOp = await this.buildTransaction({
+                    chainId,
+                    transactions,
+                    usePaymaster,
+                });
+                const opHash = await this.opHash(userOp);
+                return {
+                    payload: toPayload(opHash),
+                    evmMessage: JSON.stringify(userOp),
+                    hash: await this.opHash(userOp),
+                };
+            }
+        }
+    }
 }

package/dist/esm/types.d.ts

@@ -1,4 +1,5 @@
-import { Address, Hex } from "viem";
+import { FunctionCallTransaction, SignArgs } from "near-ca";
+import { Address, Hash, Hex, TransactionSerializable } from "viem";
 export interface UnsignedUserOperation {
     sender: Address;
     nonce: string;
@@ -89,4 +90,14 @@ export interface MetaTransaction {
     readonly data: string;
     readonly operation?: OperationType;
 }
+export interface EncodedTxData {
+    evmData: {
+        chainId: number;
+        data: string | TransactionSerializable;
+        hash: Hash;
+    };
+    nearPayload: FunctionCallTransaction<{
+        request: SignArgs;
+    }>;
+}
 export {};

package/dist/esm/util.d.ts

@@ -1,3 +1,4 @@
+import { SessionRequestParams } from "near-ca";
 import { Address, Hex, PublicClient } from "viem";
 import { PaymasterData, MetaTransaction } from "./types";
 export declare const PLACEHOLDER_SIG: `0x${string}`;
@@ -8,4 +9,5 @@ export declare function packPaymasterData(data: PaymasterData): Hex;
 export declare function containsValue(transactions: MetaTransaction[]): boolean;
 export declare function isContract(address: Address, chainId: number): Promise<boolean>;
 export declare function getClient(chainId: number): PublicClient;
+export declare function metaTransactionsFromRequest(params: SessionRequestParams): MetaTransaction[];
 export {};

package/dist/esm/util.js

@@ -1,5 +1,6 @@
 import { Network } from "near-ca";
-import { concatHex, encodePacked, toHex, } from "viem";
+import { concatHex, encodePacked, toHex, isHex, parseTransaction, zeroAddress, } from "viem";
+//
 export const PLACEHOLDER_SIG = encodePacked(["uint48", "uint48"], [0, 0]);
 export const packGas = (hi, lo) => encodePacked(["uint128", "uint128"], [BigInt(hi), BigInt(lo)]);
 export function packSignature(signature, validFrom = 0, validTo = 0) {
@@ -24,3 +25,26 @@ export async function isContract(address, chainId) {
 export function getClient(chainId) {
     return Network.fromChainId(chainId).client;
 }
+export function metaTransactionsFromRequest(params) {
+    let transactions;
+    if (isHex(params)) {
+        // If RLP hex is given, decode the transaction and build EthTransactionParams
+        const tx = parseTransaction(params);
+        transactions = [
+            {
+                from: zeroAddress, // TODO: This is a hack - but its unused.
+                to: tx.to,
+                value: tx.value ? toHex(tx.value) : "0x00",
+                data: tx.data || "0x",
+            },
+        ];
+    }
+    else {
+        transactions = params;
+    }
+    return transactions.map((tx) => ({
+        to: tx.to,
+        value: tx.value || "0x00",
+        data: tx.data || "0x",
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -41,14 +41,17 @@
   },
   "dependencies": {
     "@safe-global/safe-deployments": "^1.37.0",
+    "@safe-global/safe-gateway-typescript-sdk": "^3.22.2",
     "@safe-global/safe-modules-deployments": "^2.2.0",
     "near-api-js": "^5.0.0",
-    "near-ca": "^0.5.2",
+    "near-ca": "^0.5.6",
+    "semver": "^7.6.3",
     "viem": "^2.16.5"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node": "^22.3.0",
+    "@types/semver": "^7.5.8",
     "@types/yargs": "^17.0.32",
     "@typescript-eslint/eslint-plugin": "^8.1.0",
     "@typescript-eslint/parser": "^8.1.0",