near-safe 0.7.5 → 0.8.0

package/dist/cjs/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const USER_OP_IDENTIFIER: `0x${string}`;
 export declare const DEFAULT_SAFE_SALT_NONCE: string;
+export declare const SENTINEL_OWNERS = "0x0000000000000000000000000000000000000001";

package/dist/cjs/constants.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SAFE_SALT_NONCE = exports.USER_OP_IDENTIFIER = void 0;
+exports.SENTINEL_OWNERS = exports.DEFAULT_SAFE_SALT_NONCE = exports.USER_OP_IDENTIFIER = void 0;
 const viem_1 = require("viem");
 const DOMAIN_SEPARATOR = "bitte/near-safe";
 // 0x62697474652f6e6561722d7361666500
 exports.USER_OP_IDENTIFIER = (0, viem_1.toHex)(DOMAIN_SEPARATOR, { size: 16 });
 // 130811896738364114529934864114944206080
 exports.DEFAULT_SAFE_SALT_NONCE = BigInt(exports.USER_OP_IDENTIFIER).toString();
+exports.SENTINEL_OWNERS = "0x0000000000000000000000000000000000000001";

package/dist/cjs/decode.d.ts

@@ -0,0 +1,14 @@
+import { EIP712TypedData } from "near-ca";
+import { Hex, 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, }: SafeEncodedSignRequest): DecodedTxData;
+export declare function decodeTransactionSerializable(chainId: number, tx: TransactionSerializable): DecodedTxData;
+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;

package/dist/cjs/decode.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTxData = decodeTxData;
+exports.decodeTransactionSerializable = decodeTransactionSerializable;
+exports.decodeRlpHex = decodeRlpHex;
+exports.decodeTypedData = decodeTypedData;
+exports.decodeUserOperation = decodeUserOperation;
+const ethers_multisend_1 = require("ethers-multisend");
+const viem_1 = require("viem");
+const deployments_1 = require("./_gen/deployments");
+const multisend_1 = require("./lib/multisend");
+const safe_message_1 = require("./lib/safe-message");
+/**
+ * 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)) {
+        decodeRlpHex(chainId, evmMessage);
+    }
+    if ((0, safe_message_1.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 {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`decodeTxData: Unexpected error - ${message}`);
+        }
+    }
+}
+function decodeTransactionSerializable(chainId, tx) {
+    const { gas, maxFeePerGas, maxPriorityFeePerGas, to } = tx;
+    if (chainId !== tx.chainId) {
+        throw Error(`Transaction chainId mismatch ${chainId} != ${tx.chainId}`);
+    }
+    if (!gas || !maxFeePerGas || !maxPriorityFeePerGas) {
+        throw Error(`Insufficient feeData for ${(0, viem_1.serializeTransaction)(tx)}. Check https://rawtxdecode.in/`);
+    }
+    if (!to) {
+        throw Error(`Transaction is missing the 'to' in ${(0, viem_1.serializeTransaction)(tx)}. Check https://rawtxdecode.in/`);
+    }
+    return {
+        chainId,
+        // This is an upper bound on the gas fees (could be lower)
+        costEstimate: (0, viem_1.formatEther)(gas * (maxFeePerGas + maxPriorityFeePerGas)),
+        transactions: [
+            {
+                to,
+                value: (tx.value || 0n).toString(),
+                data: tx.data || "0x",
+            },
+        ],
+    };
+}
+function decodeRlpHex(chainId, tx) {
+    return decodeTransactionSerializable(chainId, (0, viem_1.parseTransaction)(tx));
+}
+function decodeTypedData(chainId, data) {
+    return {
+        chainId,
+        costEstimate: "0",
+        transactions: [],
+        message: data,
+    };
+}
+function decodeUserOperation(chainId, userOp) {
+    const { callGasLimit, maxFeePerGas, maxPriorityFeePerGas } = userOp;
+    const maxGasPrice = BigInt(maxFeePerGas) + BigInt(maxPriorityFeePerGas);
+    const { args } = (0, viem_1.decodeFunctionData)({
+        abi: deployments_1.SAFE_DEPLOYMENTS.m4337.abi,
+        data: userOp.callData,
+    });
+    // Determine if singular or double!
+    const transactions = (0, multisend_1.isMultisendTx)(args)
+        ? (0, ethers_multisend_1.decodeMulti)(args[2])
+        : [
+            {
+                to: args[0],
+                value: args[1],
+                data: args[2],
+                operation: args[3],
+            },
+        ];
+    return {
+        chainId,
+        // This is an upper bound on the gas fees (could be lower)
+        costEstimate: (0, viem_1.formatEther)(BigInt(callGasLimit) * maxGasPrice),
+        transactions,
+    };
+}

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 } from "viem";
+import { Hash, Hex, TransactionSerializable } from "viem";
 export type DecodedSafeMessage = {
     decodedMessage: string | EIP712TypedData;
     safeMessageMessage: string;
@@ -20,3 +20,5 @@ 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,6 +1,8 @@
 "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");
 /*
@@ -93,3 +95,22 @@ function decodeSafeMessage(message, safe) {
 // };
 // 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/lib/safe.d.ts

@@ -14,8 +14,10 @@ export declare class SafeContractSuite {
     addressForSetup(setup: Hex, saltNonce: string): Promise<Address>;
     getSetup(owners: string[]): Hex;
     addOwnerData(newOwner: Address): Hex;
+    removeOwnerData(chainId: number, safeAddress: Address, owner: Address): Promise<Hex>;
     getOpHash(chainId: number, unsignedUserOp: UserOperation): Promise<Hash>;
     private factoryDataForSetup;
     buildUserOp(nonce: bigint, txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
     getNonce(address: Address, chainId: number): Promise<bigint>;
+    prevOwner(chainId: number, safeAddress: Address, owner: Address): Promise<Address>;
 }

package/dist/cjs/lib/safe.js

@@ -65,6 +65,15 @@ class SafeContractSuite {
             args: [newOwner, 1],
         });
     }
+    async removeOwnerData(chainId, safeAddress, owner) {
+        const prevOwner = await this.prevOwner(chainId, safeAddress, owner);
+        return (0, viem_1.encodeFunctionData)({
+            abi: this.singleton.abi,
+            functionName: "removeOwner",
+            // Keep threshold at 1!
+            args: [prevOwner, owner, 1],
+        });
+    }
     async getOpHash(chainId, unsignedUserOp) {
         const { factory, factoryData, verificationGasLimit, callGasLimit, maxPriorityFeePerGas, maxFeePerGas, } = unsignedUserOp;
         const client = await (0, util_1.getClient)(chainId);
@@ -131,5 +140,21 @@ class SafeContractSuite {
         }));
         return nonce;
     }
+    async prevOwner(chainId, safeAddress, owner) {
+        const client = (0, util_1.getClient)(chainId);
+        const currentOwners = await client.readContract({
+            address: safeAddress,
+            // abi: this.singleton.abi,
+            abi: (0, viem_1.parseAbi)([
+                "function getOwners() public view returns (address[] memory)",
+            ]),
+            functionName: "getOwners",
+        });
+        const ownerIndex = currentOwners.findIndex((t) => t === owner);
+        if (ownerIndex === -1) {
+            throw new Error(`Not a current owner: ${owner}`);
+        }
+        return ownerIndex > 0 ? currentOwners[ownerIndex - 1] : constants_1.SENTINEL_OWNERS;
+    }
 }
 exports.SafeContractSuite = SafeContractSuite;

package/dist/cjs/near-safe.d.ts

@@ -1,9 +1,9 @@
 import { NearConfig } from "near-api-js/lib/near";
 import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, SignRequestData } from "near-ca";
+import { NearEthAdapter, SignRequestData, EncodedSignRequest } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { SafeContractSuite } from "./lib/safe";
-import { DecodedMultisend, EncodedTxData, EvmTransactionData, MetaTransaction, SponsorshipPolicyData, UserOperation, UserOperationReceipt } from "./types";
+import { EncodedTxData, MetaTransaction, SponsorshipPolicyData, UserOperation, UserOperationReceipt } from "./types";
 export interface NearSafeConfig {
     accountId: string;
     mpcContractId: string;
@@ -149,6 +149,14 @@ export declare class NearSafe {
      * @returns {MetaTransaction} - A meta-transaction object for adding the new owner.
      */
     addOwnerTx(address: Address): MetaTransaction;
+    /**
+     * Creates a meta-transaction for adding a new owner to the Safe contract.
+     *
+     * @param {number} chainId - the chainId to build the transaction for.
+     * @param {Address} address - The address of the new owner to be removed.
+     * @returns {Promise<MetaTransaction>} - A meta-transaction object for adding the new owner.
+     */
+    removeOwnerTx(chainId: number, address: Address): Promise<MetaTransaction>;
     /**
      * Creates and returns a new `Erc4337Bundler` instance for the specified chain.
      *
@@ -156,13 +164,6 @@ export declare class NearSafe {
      * @returns {Erc4337Bundler} - A new instance of the `Erc4337Bundler` class configured for the specified chain.
      */
     private bundlerForChainId;
-    /**
-     * Decodes transaction data for a given EVM transaction and extracts relevant details.
-     *
-     * @param {EvmTransactionData} data - The raw transaction data to be decoded.
-     * @returns {DecodedMultisend} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
-     */
-    decodeTxData(data: EvmTransactionData): DecodedMultisend;
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
      *
@@ -173,10 +174,7 @@ export declare class NearSafe {
      * - 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, sponsorshipPolicy?: string): Promise<{
-        evmMessage: string;
-        payload: number[];
-        hash: Hash;
-    }>;
+    requestRouter({ method, chainId, params }: SignRequestData, sponsorshipPolicy?: string): Promise<EncodedSignRequest>;
+    encodeForSafe(from: string): boolean;
     policyForChainId(chainId: number): Promise<SponsorshipPolicyData[]>;
 }

package/dist/cjs/near-safe.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NearSafe = void 0;
-const ethers_multisend_1 = require("ethers-multisend");
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
 const constants_1 = require("./constants");
@@ -132,17 +131,17 @@ class NearSafe {
      * @returns {Promise<EncodedTxData>} - A promise that resolves to the encoded transaction data for the NEAR and EVM networks.
      */
     async encodeSignRequest(signRequest, sponsorshipPolicy) {
-        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, sponsorshipPolicy);
+        const { evmMessage, hashToSign } = await this.requestRouter(signRequest, sponsorshipPolicy);
         return {
             nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
                 path: this.nearAdapter.derivationPath,
-                payload,
+                payload: (0, near_ca_1.toPayload)(hashToSign),
                 key_version: 0,
             }),
             evmData: {
                 chainId: signRequest.chainId,
-                data: evmMessage,
-                hash,
+                evmMessage,
+                hashToSign,
             },
         };
     }
@@ -231,6 +230,20 @@ class NearSafe {
             data: this.safePack.addOwnerData(address),
         };
     }
+    /**
+     * Creates a meta-transaction for adding a new owner to the Safe contract.
+     *
+     * @param {number} chainId - the chainId to build the transaction for.
+     * @param {Address} address - The address of the new owner to be removed.
+     * @returns {Promise<MetaTransaction>} - A meta-transaction object for adding the new owner.
+     */
+    async removeOwnerTx(chainId, address) {
+        return {
+            to: this.address,
+            value: "0",
+            data: await this.safePack.removeOwnerData(chainId, this.address, address),
+        };
+    }
     /**
      * Creates and returns a new `Erc4337Bundler` instance for the specified chain.
      *
@@ -240,54 +253,6 @@ class NearSafe {
     bundlerForChainId(chainId) {
         return new bundler_1.Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
     }
-    /**
-     * Decodes transaction data for a given EVM transaction and extracts relevant details.
-     *
-     * @param {EvmTransactionData} data - The raw transaction data to be decoded.
-     * @returns {DecodedMultisend} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
-     */
-    decodeTxData(data) {
-        try {
-            const userOp = JSON.parse(data.data);
-            const { callGasLimit, maxFeePerGas, maxPriorityFeePerGas } = userOp;
-            const maxGasPrice = BigInt(maxFeePerGas) + BigInt(maxPriorityFeePerGas);
-            const { args } = (0, viem_1.decodeFunctionData)({
-                abi: this.safePack.m4337.abi,
-                data: userOp.callData,
-            });
-            // Determine if singular or double!
-            const transactions = (0, multisend_1.isMultisendTx)(args)
-                ? (0, ethers_multisend_1.decodeMulti)(args[2])
-                : [
-                    {
-                        to: args[0],
-                        value: args[1],
-                        data: args[2],
-                        operation: args[3],
-                    },
-                ];
-            return {
-                chainId: data.chainId,
-                // This is an upper bound on the gas fees (could be lower)
-                costEstimate: (0, viem_1.formatEther)(BigInt(callGasLimit) * maxGasPrice),
-                transactions,
-            };
-        }
-        catch (error) {
-            if (error instanceof SyntaxError) {
-                return {
-                    chainId: data.chainId,
-                    costEstimate: "0",
-                    transactions: [],
-                    message: data.data,
-                };
-            }
-            else {
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`decodeTxData: Unexpected error - ${message}`);
-            }
-        }
-    }
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
      *
@@ -299,6 +264,27 @@ class NearSafe {
      *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
      */
     async requestRouter({ method, chainId, params }, sponsorshipPolicy) {
+        // Extract `from` based on the method and check uniqueness
+        const fromAddresses = (() => {
+            switch (method) {
+                case "eth_signTypedData":
+                case "eth_signTypedData_v4":
+                case "eth_sign":
+                    return [params[0]];
+                case "personal_sign":
+                    return [params[1]];
+                case "eth_sendTransaction":
+                    return params.map((p) => p.from);
+                default:
+                    return [];
+            }
+        })();
+        // Assert uniqueness
+        (0, util_1.assertUnique)(fromAddresses);
+        // Early return with eoaEncoding if `from` is not the Safe
+        if (!this.encodeForSafe(fromAddresses[0])) {
+            return (0, near_ca_1.requestRouter)({ method, chainId, params });
+        }
         const safeInfo = {
             address: { value: this.address },
             chainId: chainId.toString(),
@@ -314,23 +300,21 @@ class NearSafe {
                 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,
+                    evmMessage: message.decodedMessage,
+                    hashToSign: message.safeMessageHash,
                 };
             }
             case "personal_sign": {
                 const [messageHash, _] = params;
                 const message = (0, safe_message_1.decodeSafeMessage)(messageHash, safeInfo);
                 return {
-                    // TODO(bh2smith) this is a bit of a hack.
                     evmMessage: message.decodedMessage,
-                    payload: (0, near_ca_1.toPayload)(message.safeMessageHash),
-                    hash: message.safeMessageHash,
+                    hashToSign: message.safeMessageHash,
                 };
             }
             case "eth_sendTransaction": {
-                const transactions = (0, util_1.metaTransactionsFromRequest)(params);
+                const castParams = params;
+                const transactions = (0, util_1.metaTransactionsFromRequest)(castParams);
                 const userOp = await this.buildTransaction({
                     chainId,
                     transactions,
@@ -338,13 +322,21 @@ class NearSafe {
                 });
                 const opHash = await this.opHash(chainId, userOp);
                 return {
-                    payload: (0, near_ca_1.toPayload)(opHash),
                     evmMessage: JSON.stringify(userOp),
-                    hash: await this.opHash(chainId, userOp),
+                    hashToSign: opHash,
                 };
             }
         }
     }
+    encodeForSafe(from) {
+        const fromLower = from.toLowerCase();
+        if (![this.address, this.mpcAddress]
+            .map((t) => t.toLowerCase())
+            .includes(fromLower)) {
+            throw new Error(`Unexpected from address ${from}`);
+        }
+        return this.address.toLowerCase() === fromLower;
+    }
     async policyForChainId(chainId) {
         const bundler = this.bundlerForChainId(chainId);
         return bundler.getSponsorshipPolicies();

package/dist/cjs/types.d.ts

@@ -1,4 +1,4 @@
-import { FunctionCallTransaction, SignArgs } from "near-ca";
+import { EIP712TypedData, EncodedSignRequest, FunctionCallTransaction, SignArgs } from "near-ca";
 import { Address, Hex, ParseAbi } from "viem";
 /**
  * Represents a collection of Safe contract deployments, each with its own address and ABI.
@@ -212,20 +212,15 @@ export interface MetaTransaction {
     readonly operation?: OperationType;
 }
 /**
- * Represents raw transaction data for an EVM transaction.
+ * Extends EncodedSignRequest to include a chain ID for cross-chain compatibility.
  */
-export interface EvmTransactionData {
-    /** The chain ID of the network where the transaction is being executed. */
+export interface SafeEncodedSignRequest extends EncodedSignRequest {
     chainId: number;
-    /** The raw data of the transaction. */
-    data: string;
-    /** The hash of the transaction. */
-    hash: string;
 }
 /**
  * Represents the decoded details of a multisend transaction.
  */
-export interface DecodedMultisend {
+export interface DecodedTxData {
     /** The chain ID of the network where the multisend transaction is being executed. */
     chainId: number;
     /** The estimated cost of the multisend transaction in Ether.
@@ -235,14 +230,14 @@ export interface DecodedMultisend {
     /** The list of meta-transactions included in the multisend. */
     transactions: MetaTransaction[];
     /** Raw Message to sign if no transactions present. */
-    message?: string;
+    message?: string | EIP712TypedData;
 }
 /**
  * Represents encoded transaction data for both NEAR and EVM networks.
  */
 export interface EncodedTxData {
     /** The encoded transaction data for the EVM network. */
-    evmData: EvmTransactionData;
+    evmData: SafeEncodedSignRequest;
     /** The encoded payload for a NEAR function call, including the signing arguments. */
     nearPayload: FunctionCallTransaction<{
         request: SignArgs;

package/dist/cjs/util.d.ts

@@ -37,4 +37,5 @@ export declare function signatureFromTxHash(txHash: string, accountId?: string):
  * @throws Will throw an error if all promises reject with the message "All promises rejected".
  */
 export declare function raceToFirstResolve<T>(promises: Promise<T>[]): Promise<T>;
+export declare function assertUnique<T>(iterable: Iterable<T>, errorMessage?: string): void;
 export {};

package/dist/cjs/util.js

@@ -10,6 +10,7 @@ exports.metaTransactionsFromRequest = metaTransactionsFromRequest;
 exports.saltNonceFromMessage = saltNonceFromMessage;
 exports.signatureFromTxHash = signatureFromTxHash;
 exports.raceToFirstResolve = raceToFirstResolve;
+exports.assertUnique = assertUnique;
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
 exports.PLACEHOLDER_SIG = (0, viem_1.encodePacked)(["uint48", "uint48"], [0, 0]);
@@ -40,6 +41,7 @@ function getClient(chainId) {
 function metaTransactionsFromRequest(params) {
     let transactions;
     if ((0, viem_1.isHex)(params)) {
+        // TODO: Consider deprecating this route.
         // If RLP hex is given, decode the transaction and build EthTransactionParams
         const tx = (0, viem_1.parseTransaction)(params);
         transactions = [
@@ -52,6 +54,7 @@ function metaTransactionsFromRequest(params) {
         ];
     }
     else {
+        // TODO: add type guard here.
         transactions = params;
     }
     return transactions.map((tx) => ({
@@ -130,3 +133,9 @@ async function raceToFirstResolve(promises) {
         });
     });
 }
+function assertUnique(iterable, errorMessage = "The collection contains more than one distinct element.") {
+    const uniqueValues = new Set(iterable);
+    if (uniqueValues.size > 1) {
+        throw new Error(errorMessage);
+    }
+}

package/dist/esm/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const USER_OP_IDENTIFIER: `0x${string}`;
 export declare const DEFAULT_SAFE_SALT_NONCE: string;
+export declare const SENTINEL_OWNERS = "0x0000000000000000000000000000000000000001";

package/dist/esm/constants.js

@@ -4,3 +4,4 @@ const DOMAIN_SEPARATOR = "bitte/near-safe";
 export const USER_OP_IDENTIFIER = toHex(DOMAIN_SEPARATOR, { size: 16 });
 // 130811896738364114529934864114944206080
 export const DEFAULT_SAFE_SALT_NONCE = BigInt(USER_OP_IDENTIFIER).toString();
+export const SENTINEL_OWNERS = "0x0000000000000000000000000000000000000001";

package/dist/esm/decode.d.ts

@@ -0,0 +1,14 @@
+import { EIP712TypedData } from "near-ca";
+import { Hex, 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, }: SafeEncodedSignRequest): DecodedTxData;
+export declare function decodeTransactionSerializable(chainId: number, tx: TransactionSerializable): DecodedTxData;
+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;

package/dist/esm/decode.js

@@ -0,0 +1,103 @@
+import { decodeMulti } from "ethers-multisend";
+import { decodeFunctionData, formatEther, parseTransaction, serializeTransaction, } from "viem";
+import { SAFE_DEPLOYMENTS } from "./_gen/deployments";
+import { isMultisendTx } from "./lib/multisend";
+import { isRlpHex, isTransactionSerializable } from "./lib/safe-message";
+/**
+ * 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)) {
+        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 {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`decodeTxData: Unexpected error - ${message}`);
+        }
+    }
+}
+export function decodeTransactionSerializable(chainId, tx) {
+    const { gas, maxFeePerGas, maxPriorityFeePerGas, to } = tx;
+    if (chainId !== tx.chainId) {
+        throw Error(`Transaction chainId mismatch ${chainId} != ${tx.chainId}`);
+    }
+    if (!gas || !maxFeePerGas || !maxPriorityFeePerGas) {
+        throw Error(`Insufficient feeData for ${serializeTransaction(tx)}. Check https://rawtxdecode.in/`);
+    }
+    if (!to) {
+        throw Error(`Transaction is missing the 'to' in ${serializeTransaction(tx)}. Check https://rawtxdecode.in/`);
+    }
+    return {
+        chainId,
+        // This is an upper bound on the gas fees (could be lower)
+        costEstimate: formatEther(gas * (maxFeePerGas + maxPriorityFeePerGas)),
+        transactions: [
+            {
+                to,
+                value: (tx.value || 0n).toString(),
+                data: tx.data || "0x",
+            },
+        ],
+    };
+}
+export function decodeRlpHex(chainId, tx) {
+    return decodeTransactionSerializable(chainId, parseTransaction(tx));
+}
+export function decodeTypedData(chainId, data) {
+    return {
+        chainId,
+        costEstimate: "0",
+        transactions: [],
+        message: data,
+    };
+}
+export function decodeUserOperation(chainId, userOp) {
+    const { callGasLimit, maxFeePerGas, maxPriorityFeePerGas } = userOp;
+    const maxGasPrice = BigInt(maxFeePerGas) + BigInt(maxPriorityFeePerGas);
+    const { args } = decodeFunctionData({
+        abi: SAFE_DEPLOYMENTS.m4337.abi,
+        data: userOp.callData,
+    });
+    // Determine if singular or double!
+    const transactions = isMultisendTx(args)
+        ? decodeMulti(args[2])
+        : [
+            {
+                to: args[0],
+                value: args[1],
+                data: args[2],
+                operation: args[3],
+            },
+        ];
+    return {
+        chainId,
+        // This is an upper bound on the gas fees (could be lower)
+        costEstimate: formatEther(BigInt(callGasLimit) * maxGasPrice),
+        transactions,
+    };
+}

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 } from "viem";
+import { Hash, Hex, TransactionSerializable } from "viem";
 export type DecodedSafeMessage = {
     decodedMessage: string | EIP712TypedData;
     safeMessageMessage: string;
@@ -20,3 +20,5 @@ 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, } from "viem";
+import { fromHex, hashMessage, hashTypedData, isHex, parseTransaction, serializeTransaction, } 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
@@ -90,3 +90,22 @@ export function decodeSafeMessage(message, safe) {
 // };
 // 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/lib/safe.d.ts

@@ -14,8 +14,10 @@ export declare class SafeContractSuite {
     addressForSetup(setup: Hex, saltNonce: string): Promise<Address>;
     getSetup(owners: string[]): Hex;
     addOwnerData(newOwner: Address): Hex;
+    removeOwnerData(chainId: number, safeAddress: Address, owner: Address): Promise<Hex>;
     getOpHash(chainId: number, unsignedUserOp: UserOperation): Promise<Hash>;
     private factoryDataForSetup;
     buildUserOp(nonce: bigint, txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
     getNonce(address: Address, chainId: number): Promise<bigint>;
+    prevOwner(chainId: number, safeAddress: Address, owner: Address): Promise<Address>;
 }

package/dist/esm/lib/safe.js

@@ -1,6 +1,6 @@
-import { concat, encodeFunctionData, encodePacked, getAddress, getCreate2Address, keccak256, toHex, zeroAddress, } from "viem";
+import { concat, encodeFunctionData, encodePacked, getAddress, getCreate2Address, keccak256, parseAbi, toHex, zeroAddress, } from "viem";
 import { SAFE_DEPLOYMENTS } from "../_gen/deployments";
-import { USER_OP_IDENTIFIER } from "../constants";
+import { SENTINEL_OWNERS, USER_OP_IDENTIFIER } from "../constants";
 import { PLACEHOLDER_SIG, getClient, packGas, packPaymasterData, } from "../util";
 /**
  * All contracts used in account creation & execution
@@ -69,6 +69,15 @@ export class SafeContractSuite {
             args: [newOwner, 1],
         });
     }
+    async removeOwnerData(chainId, safeAddress, owner) {
+        const prevOwner = await this.prevOwner(chainId, safeAddress, owner);
+        return encodeFunctionData({
+            abi: this.singleton.abi,
+            functionName: "removeOwner",
+            // Keep threshold at 1!
+            args: [prevOwner, owner, 1],
+        });
+    }
     async getOpHash(chainId, unsignedUserOp) {
         const { factory, factoryData, verificationGasLimit, callGasLimit, maxPriorityFeePerGas, maxFeePerGas, } = unsignedUserOp;
         const client = await getClient(chainId);
@@ -135,4 +144,20 @@ export class SafeContractSuite {
         }));
         return nonce;
     }
+    async prevOwner(chainId, safeAddress, owner) {
+        const client = getClient(chainId);
+        const currentOwners = await client.readContract({
+            address: safeAddress,
+            // abi: this.singleton.abi,
+            abi: parseAbi([
+                "function getOwners() public view returns (address[] memory)",
+            ]),
+            functionName: "getOwners",
+        });
+        const ownerIndex = currentOwners.findIndex((t) => t === owner);
+        if (ownerIndex === -1) {
+            throw new Error(`Not a current owner: ${owner}`);
+        }
+        return ownerIndex > 0 ? currentOwners[ownerIndex - 1] : SENTINEL_OWNERS;
+    }
 }

package/dist/esm/near-safe.d.ts

@@ -1,9 +1,9 @@
 import { NearConfig } from "near-api-js/lib/near";
 import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, SignRequestData } from "near-ca";
+import { NearEthAdapter, SignRequestData, EncodedSignRequest } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { SafeContractSuite } from "./lib/safe";
-import { DecodedMultisend, EncodedTxData, EvmTransactionData, MetaTransaction, SponsorshipPolicyData, UserOperation, UserOperationReceipt } from "./types";
+import { EncodedTxData, MetaTransaction, SponsorshipPolicyData, UserOperation, UserOperationReceipt } from "./types";
 export interface NearSafeConfig {
     accountId: string;
     mpcContractId: string;
@@ -149,6 +149,14 @@ export declare class NearSafe {
      * @returns {MetaTransaction} - A meta-transaction object for adding the new owner.
      */
     addOwnerTx(address: Address): MetaTransaction;
+    /**
+     * Creates a meta-transaction for adding a new owner to the Safe contract.
+     *
+     * @param {number} chainId - the chainId to build the transaction for.
+     * @param {Address} address - The address of the new owner to be removed.
+     * @returns {Promise<MetaTransaction>} - A meta-transaction object for adding the new owner.
+     */
+    removeOwnerTx(chainId: number, address: Address): Promise<MetaTransaction>;
     /**
      * Creates and returns a new `Erc4337Bundler` instance for the specified chain.
      *
@@ -156,13 +164,6 @@ export declare class NearSafe {
      * @returns {Erc4337Bundler} - A new instance of the `Erc4337Bundler` class configured for the specified chain.
      */
     private bundlerForChainId;
-    /**
-     * Decodes transaction data for a given EVM transaction and extracts relevant details.
-     *
-     * @param {EvmTransactionData} data - The raw transaction data to be decoded.
-     * @returns {DecodedMultisend} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
-     */
-    decodeTxData(data: EvmTransactionData): DecodedMultisend;
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
      *
@@ -173,10 +174,7 @@ export declare class NearSafe {
      * - 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, sponsorshipPolicy?: string): Promise<{
-        evmMessage: string;
-        payload: number[];
-        hash: Hash;
-    }>;
+    requestRouter({ method, chainId, params }: SignRequestData, sponsorshipPolicy?: string): Promise<EncodedSignRequest>;
+    encodeForSafe(from: string): boolean;
     policyForChainId(chainId: number): Promise<SponsorshipPolicyData[]>;
 }

package/dist/esm/near-safe.js

@@ -1,12 +1,11 @@
-import { decodeMulti } from "ethers-multisend";
-import { setupAdapter, signatureFromOutcome, toPayload, } from "near-ca";
-import { decodeFunctionData, formatEther, serializeSignature, } from "viem";
+import { setupAdapter, signatureFromOutcome, toPayload, requestRouter as mpcRequestRouter, } from "near-ca";
+import { serializeSignature } from "viem";
 import { DEFAULT_SAFE_SALT_NONCE } from "./constants";
 import { Erc4337Bundler } from "./lib/bundler";
-import { encodeMulti, isMultisendTx } from "./lib/multisend";
+import { encodeMulti } from "./lib/multisend";
 import { SafeContractSuite } from "./lib/safe";
 import { decodeSafeMessage } from "./lib/safe-message";
-import { getClient, isContract, metaTransactionsFromRequest, packSignature, } from "./util";
+import { assertUnique, getClient, isContract, metaTransactionsFromRequest, packSignature, } from "./util";
 export class NearSafe {
     nearAdapter;
     address;
@@ -135,17 +134,17 @@ export class NearSafe {
      * @returns {Promise<EncodedTxData>} - A promise that resolves to the encoded transaction data for the NEAR and EVM networks.
      */
     async encodeSignRequest(signRequest, sponsorshipPolicy) {
-        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, sponsorshipPolicy);
+        const { evmMessage, hashToSign } = await this.requestRouter(signRequest, sponsorshipPolicy);
         return {
             nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
                 path: this.nearAdapter.derivationPath,
-                payload,
+                payload: toPayload(hashToSign),
                 key_version: 0,
             }),
             evmData: {
                 chainId: signRequest.chainId,
-                data: evmMessage,
-                hash,
+                evmMessage,
+                hashToSign,
             },
         };
     }
@@ -234,6 +233,20 @@ export class NearSafe {
             data: this.safePack.addOwnerData(address),
         };
     }
+    /**
+     * Creates a meta-transaction for adding a new owner to the Safe contract.
+     *
+     * @param {number} chainId - the chainId to build the transaction for.
+     * @param {Address} address - The address of the new owner to be removed.
+     * @returns {Promise<MetaTransaction>} - A meta-transaction object for adding the new owner.
+     */
+    async removeOwnerTx(chainId, address) {
+        return {
+            to: this.address,
+            value: "0",
+            data: await this.safePack.removeOwnerData(chainId, this.address, address),
+        };
+    }
     /**
      * Creates and returns a new `Erc4337Bundler` instance for the specified chain.
      *
@@ -243,54 +256,6 @@ export class NearSafe {
     bundlerForChainId(chainId) {
         return new Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
     }
-    /**
-     * Decodes transaction data for a given EVM transaction and extracts relevant details.
-     *
-     * @param {EvmTransactionData} data - The raw transaction data to be decoded.
-     * @returns {DecodedMultisend} - An object containing the chain ID, estimated cost, and a list of decoded meta-transactions.
-     */
-    decodeTxData(data) {
-        try {
-            const userOp = JSON.parse(data.data);
-            const { callGasLimit, maxFeePerGas, maxPriorityFeePerGas } = userOp;
-            const maxGasPrice = BigInt(maxFeePerGas) + BigInt(maxPriorityFeePerGas);
-            const { args } = decodeFunctionData({
-                abi: this.safePack.m4337.abi,
-                data: userOp.callData,
-            });
-            // Determine if singular or double!
-            const transactions = isMultisendTx(args)
-                ? decodeMulti(args[2])
-                : [
-                    {
-                        to: args[0],
-                        value: args[1],
-                        data: args[2],
-                        operation: args[3],
-                    },
-                ];
-            return {
-                chainId: data.chainId,
-                // This is an upper bound on the gas fees (could be lower)
-                costEstimate: formatEther(BigInt(callGasLimit) * maxGasPrice),
-                transactions,
-            };
-        }
-        catch (error) {
-            if (error instanceof SyntaxError) {
-                return {
-                    chainId: data.chainId,
-                    costEstimate: "0",
-                    transactions: [],
-                    message: data.data,
-                };
-            }
-            else {
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`decodeTxData: Unexpected error - ${message}`);
-            }
-        }
-    }
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
      *
@@ -302,6 +267,27 @@ export class NearSafe {
      *   the payload (hashed data), and recovery data needed for reconstructing the signature request.
      */
     async requestRouter({ method, chainId, params }, sponsorshipPolicy) {
+        // Extract `from` based on the method and check uniqueness
+        const fromAddresses = (() => {
+            switch (method) {
+                case "eth_signTypedData":
+                case "eth_signTypedData_v4":
+                case "eth_sign":
+                    return [params[0]];
+                case "personal_sign":
+                    return [params[1]];
+                case "eth_sendTransaction":
+                    return params.map((p) => p.from);
+                default:
+                    return [];
+            }
+        })();
+        // Assert uniqueness
+        assertUnique(fromAddresses);
+        // Early return with eoaEncoding if `from` is not the Safe
+        if (!this.encodeForSafe(fromAddresses[0])) {
+            return mpcRequestRouter({ method, chainId, params });
+        }
         const safeInfo = {
             address: { value: this.address },
             chainId: chainId.toString(),
@@ -317,23 +303,21 @@ export class NearSafe {
                 const [_, messageOrData] = params;
                 const message = decodeSafeMessage(messageOrData, safeInfo);
                 return {
-                    evmMessage: message.safeMessageMessage,
-                    payload: toPayload(message.safeMessageHash),
-                    hash: message.safeMessageHash,
+                    evmMessage: message.decodedMessage,
+                    hashToSign: message.safeMessageHash,
                 };
             }
             case "personal_sign": {
                 const [messageHash, _] = params;
                 const message = decodeSafeMessage(messageHash, safeInfo);
                 return {
-                    // TODO(bh2smith) this is a bit of a hack.
                     evmMessage: message.decodedMessage,
-                    payload: toPayload(message.safeMessageHash),
-                    hash: message.safeMessageHash,
+                    hashToSign: message.safeMessageHash,
                 };
             }
             case "eth_sendTransaction": {
-                const transactions = metaTransactionsFromRequest(params);
+                const castParams = params;
+                const transactions = metaTransactionsFromRequest(castParams);
                 const userOp = await this.buildTransaction({
                     chainId,
                     transactions,
@@ -341,13 +325,21 @@ export class NearSafe {
                 });
                 const opHash = await this.opHash(chainId, userOp);
                 return {
-                    payload: toPayload(opHash),
                     evmMessage: JSON.stringify(userOp),
-                    hash: await this.opHash(chainId, userOp),
+                    hashToSign: opHash,
                 };
             }
         }
     }
+    encodeForSafe(from) {
+        const fromLower = from.toLowerCase();
+        if (![this.address, this.mpcAddress]
+            .map((t) => t.toLowerCase())
+            .includes(fromLower)) {
+            throw new Error(`Unexpected from address ${from}`);
+        }
+        return this.address.toLowerCase() === fromLower;
+    }
     async policyForChainId(chainId) {
         const bundler = this.bundlerForChainId(chainId);
         return bundler.getSponsorshipPolicies();

package/dist/esm/types.d.ts

@@ -1,4 +1,4 @@
-import { FunctionCallTransaction, SignArgs } from "near-ca";
+import { EIP712TypedData, EncodedSignRequest, FunctionCallTransaction, SignArgs } from "near-ca";
 import { Address, Hex, ParseAbi } from "viem";
 /**
  * Represents a collection of Safe contract deployments, each with its own address and ABI.
@@ -212,20 +212,15 @@ export interface MetaTransaction {
     readonly operation?: OperationType;
 }
 /**
- * Represents raw transaction data for an EVM transaction.
+ * Extends EncodedSignRequest to include a chain ID for cross-chain compatibility.
  */
-export interface EvmTransactionData {
-    /** The chain ID of the network where the transaction is being executed. */
+export interface SafeEncodedSignRequest extends EncodedSignRequest {
     chainId: number;
-    /** The raw data of the transaction. */
-    data: string;
-    /** The hash of the transaction. */
-    hash: string;
 }
 /**
  * Represents the decoded details of a multisend transaction.
  */
-export interface DecodedMultisend {
+export interface DecodedTxData {
     /** The chain ID of the network where the multisend transaction is being executed. */
     chainId: number;
     /** The estimated cost of the multisend transaction in Ether.
@@ -235,14 +230,14 @@ export interface DecodedMultisend {
     /** The list of meta-transactions included in the multisend. */
     transactions: MetaTransaction[];
     /** Raw Message to sign if no transactions present. */
-    message?: string;
+    message?: string | EIP712TypedData;
 }
 /**
  * Represents encoded transaction data for both NEAR and EVM networks.
  */
 export interface EncodedTxData {
     /** The encoded transaction data for the EVM network. */
-    evmData: EvmTransactionData;
+    evmData: SafeEncodedSignRequest;
     /** The encoded payload for a NEAR function call, including the signing arguments. */
     nearPayload: FunctionCallTransaction<{
         request: SignArgs;

package/dist/esm/util.d.ts

@@ -37,4 +37,5 @@ export declare function signatureFromTxHash(txHash: string, accountId?: string):
  * @throws Will throw an error if all promises reject with the message "All promises rejected".
  */
 export declare function raceToFirstResolve<T>(promises: Promise<T>[]): Promise<T>;
+export declare function assertUnique<T>(iterable: Iterable<T>, errorMessage?: string): void;
 export {};

package/dist/esm/util.js

@@ -27,6 +27,7 @@ export function getClient(chainId) {
 export function metaTransactionsFromRequest(params) {
     let transactions;
     if (isHex(params)) {
+        // TODO: Consider deprecating this route.
         // If RLP hex is given, decode the transaction and build EthTransactionParams
         const tx = parseTransaction(params);
         transactions = [
@@ -39,6 +40,7 @@ export function metaTransactionsFromRequest(params) {
         ];
     }
     else {
+        // TODO: add type guard here.
         transactions = params;
     }
     return transactions.map((tx) => ({
@@ -117,3 +119,9 @@ export async function raceToFirstResolve(promises) {
         });
     });
 }
+export function assertUnique(iterable, errorMessage = "The collection contains more than one distinct element.") {
+    const uniqueValues = new Set(iterable);
+    if (uniqueValues.size > 1) {
+        throw new Error(errorMessage);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.7.5",
+  "version": "0.8.0",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -44,7 +44,7 @@
     "@safe-global/safe-gateway-typescript-sdk": "^3.22.2",
     "ethers-multisend": "^3.1.0",
     "near-api-js": "^5.0.0",
-    "near-ca": "^0.5.10",
+    "near-ca": "^0.6.0",
     "semver": "^7.6.3",
     "viem": "^2.16.5"
   },