near-safe 0.8.4 → 0.8.5

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

@@ -5,3 +5,13 @@ 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/decode/util.js

@@ -4,7 +4,6 @@ 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");
@@ -52,7 +51,7 @@ function decodeUserOperation(chainId, userOp) {
     });
     // Determine if singular or double!
     const transactions = (0, multisend_1.isMultisendTx)(args)
-        ? (0, ethers_multisend_1.decodeMulti)(args[2])
+        ? (0, multisend_1.decodeMulti)(args[2])
         : [
             {
                 to: args[0],

package/dist/cjs/lib/multisend.d.ts

@@ -1,4 +1,6 @@
+import { Hex } from "viem";
 import { MetaTransaction } from "../types";
 export declare const MULTI_SEND_ABI: string[];
 export declare function encodeMulti(transactions: readonly MetaTransaction[], multiSendContractAddress?: string): MetaTransaction;
 export declare function isMultisendTx(args: readonly unknown[]): boolean;
+export declare function decodeMulti(data: Hex): MetaTransaction[];

package/dist/cjs/lib/multisend.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MULTI_SEND_ABI = void 0;
 exports.encodeMulti = encodeMulti;
 exports.isMultisendTx = isMultisendTx;
+exports.decodeMulti = decodeMulti;
 const viem_1 = require("viem");
 const types_1 = require("../types");
 exports.MULTI_SEND_ABI = ["function multiSend(bytes memory transactions)"];
@@ -44,3 +45,37 @@ function isMultisendTx(args) {
     return (to === MULTISEND_141.toLowerCase() ||
         to === MULTISEND_CALLONLY_141.toLowerCase());
 }
+function unpack(packed, startIndex) {
+    // read operation from first 8 bits (= 2 hex digits)
+    const operation = parseInt(packed.substring(startIndex, startIndex + 2), 16);
+    // the next 40 characters are the to address
+    const to = (0, viem_1.getAddress)(`0x${packed.substring(startIndex + 2, startIndex + 42)}`);
+    // then comes the uint256 value (= 64 hex digits)
+    const value = (0, viem_1.toHex)(BigInt(`0x${packed.substring(startIndex + 42, startIndex + 106)}`));
+    // and the uint256 data length (= 64 hex digits)
+    const hexDataLength = parseInt(packed.substring(startIndex + 106, startIndex + 170), 16);
+    const endIndex = startIndex + 170 + hexDataLength * 2; // * 2 because each hex item is represented with 2 digits
+    const data = `0x${packed.substring(startIndex + 170, endIndex)}`;
+    return {
+        operation,
+        to,
+        value,
+        data,
+        endIndex,
+    };
+}
+function decodeMulti(data) {
+    const tx = (0, viem_1.decodeFunctionData)({
+        abi: (0, viem_1.parseAbi)(exports.MULTI_SEND_ABI),
+        data,
+    });
+    const [transactionsEncoded] = tx.args;
+    const result = [];
+    let startIndex = 2; // skip over 0x
+    while (startIndex < transactionsEncoded.length) {
+        const { endIndex, ...tx } = unpack(transactionsEncoded, startIndex);
+        result.push(tx);
+        startIndex = endIndex;
+    }
+    return result;
+}

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

@@ -1,5 +1,4 @@
 import { NearConfig } from "near-api-js/lib/near";
-import { FinalExecutionOutcome } from "near-api-js/lib/providers";
 import { NearEthAdapter, SignRequestData, EncodedSignRequest } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { SafeContractSuite } from "./lib/safe";
@@ -99,15 +98,12 @@ export declare class NearSafe {
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).
      *
      * @param {number} chainId - The ID of the EVM network to which the transaction should be broadcasted.
-     * @param {FinalExecutionOutcome} outcome - The result of the NEAR transaction execution, which contains the necessary data to construct an EVM signature.
+     * @param {Signature} signature - The valid signature of the unsignedUserOp.
      * @param {UserOperation} unsignedUserOp - The unsigned user operation to be broadcasted. This includes transaction data such as the destination address and data payload.
-     * @returns {Promise<{ signature: Hex; opHash: Hash }>} - A promise that resolves to an object containing the signature used and the hash of the executed user operation.
+     * @returns {Promise<Hash>} - A promise that resolves hash of the executed user operation.
      * @throws {Error} - Throws an error if the EVM broadcast fails, including the error message for debugging.
      */
-    broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
-        signature: Hex;
-        opHash: Hash;
-    }>;
+    broadcastBundler(chainId: number, signatureHex: Hex, unsignedUserOp: UserOperation): Promise<Hash>;
     /**
      * Executes a user operation on the specified blockchain network.
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).

package/dist/cjs/near-safe.js

@@ -150,24 +150,20 @@ class NearSafe {
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).
      *
      * @param {number} chainId - The ID of the EVM network to which the transaction should be broadcasted.
-     * @param {FinalExecutionOutcome} outcome - The result of the NEAR transaction execution, which contains the necessary data to construct an EVM signature.
+     * @param {Signature} signature - The valid signature of the unsignedUserOp.
      * @param {UserOperation} unsignedUserOp - The unsigned user operation to be broadcasted. This includes transaction data such as the destination address and data payload.
-     * @returns {Promise<{ signature: Hex; opHash: Hash }>} - A promise that resolves to an object containing the signature used and the hash of the executed user operation.
+     * @returns {Promise<Hash>} - A promise that resolves hash of the executed user operation.
      * @throws {Error} - Throws an error if the EVM broadcast fails, including the error message for debugging.
      */
-    async broadcastEvm(chainId, outcome, unsignedUserOp) {
-        const signature = (0, util_1.packSignature)((0, viem_1.serializeSignature)((0, near_ca_1.signatureFromOutcome)(outcome)));
+    async broadcastBundler(chainId, signatureHex, unsignedUserOp) {
         try {
-            return {
-                signature,
-                opHash: await this.executeTransaction(chainId, {
-                    ...unsignedUserOp,
-                    signature,
-                }),
-            };
+            return this.executeTransaction(chainId, {
+                ...unsignedUserOp,
+                signature: (0, util_1.packSignature)(signatureHex),
+            });
         }
         catch (error) {
-            throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Failed Bundler broadcast: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**

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

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

package/dist/esm/decode/util.js

@@ -1,7 +1,6 @@
-import { decodeMulti } from "ethers-multisend";
 import { decodeFunctionData, formatEther, parseTransaction, serializeTransaction, } from "viem";
 import { SAFE_DEPLOYMENTS } from "../_gen/deployments";
-import { isMultisendTx } from "../lib/multisend";
+import { decodeMulti, isMultisendTx } from "../lib/multisend";
 export function decodeTransactionSerializable(chainId, tx) {
     const { gas, maxFeePerGas, maxPriorityFeePerGas, to } = tx;
     if (chainId !== tx.chainId) {

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

@@ -1,4 +1,6 @@
+import { Hex } from "viem";
 import { MetaTransaction } from "../types";
 export declare const MULTI_SEND_ABI: string[];
 export declare function encodeMulti(transactions: readonly MetaTransaction[], multiSendContractAddress?: string): MetaTransaction;
 export declare function isMultisendTx(args: readonly unknown[]): boolean;
+export declare function decodeMulti(data: Hex): MetaTransaction[];

package/dist/esm/lib/multisend.js

@@ -1,4 +1,4 @@
-import { encodeFunctionData, encodePacked, parseAbi, size, } from "viem";
+import { decodeFunctionData, encodeFunctionData, encodePacked, getAddress, parseAbi, size, toHex, } from "viem";
 import { OperationType } from "../types";
 export const MULTI_SEND_ABI = ["function multiSend(bytes memory transactions)"];
 const MULTISEND_141 = "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526";
@@ -39,3 +39,37 @@ export function isMultisendTx(args) {
     return (to === MULTISEND_141.toLowerCase() ||
         to === MULTISEND_CALLONLY_141.toLowerCase());
 }
+function unpack(packed, startIndex) {
+    // read operation from first 8 bits (= 2 hex digits)
+    const operation = parseInt(packed.substring(startIndex, startIndex + 2), 16);
+    // the next 40 characters are the to address
+    const to = getAddress(`0x${packed.substring(startIndex + 2, startIndex + 42)}`);
+    // then comes the uint256 value (= 64 hex digits)
+    const value = toHex(BigInt(`0x${packed.substring(startIndex + 42, startIndex + 106)}`));
+    // and the uint256 data length (= 64 hex digits)
+    const hexDataLength = parseInt(packed.substring(startIndex + 106, startIndex + 170), 16);
+    const endIndex = startIndex + 170 + hexDataLength * 2; // * 2 because each hex item is represented with 2 digits
+    const data = `0x${packed.substring(startIndex + 170, endIndex)}`;
+    return {
+        operation,
+        to,
+        value,
+        data,
+        endIndex,
+    };
+}
+export function decodeMulti(data) {
+    const tx = decodeFunctionData({
+        abi: parseAbi(MULTI_SEND_ABI),
+        data,
+    });
+    const [transactionsEncoded] = tx.args;
+    const result = [];
+    let startIndex = 2; // skip over 0x
+    while (startIndex < transactionsEncoded.length) {
+        const { endIndex, ...tx } = unpack(transactionsEncoded, startIndex);
+        result.push(tx);
+        startIndex = endIndex;
+    }
+    return result;
+}

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

@@ -1,5 +1,4 @@
 import { NearConfig } from "near-api-js/lib/near";
-import { FinalExecutionOutcome } from "near-api-js/lib/providers";
 import { NearEthAdapter, SignRequestData, EncodedSignRequest } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { SafeContractSuite } from "./lib/safe";
@@ -99,15 +98,12 @@ export declare class NearSafe {
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).
      *
      * @param {number} chainId - The ID of the EVM network to which the transaction should be broadcasted.
-     * @param {FinalExecutionOutcome} outcome - The result of the NEAR transaction execution, which contains the necessary data to construct an EVM signature.
+     * @param {Signature} signature - The valid signature of the unsignedUserOp.
      * @param {UserOperation} unsignedUserOp - The unsigned user operation to be broadcasted. This includes transaction data such as the destination address and data payload.
-     * @returns {Promise<{ signature: Hex; opHash: Hash }>} - A promise that resolves to an object containing the signature used and the hash of the executed user operation.
+     * @returns {Promise<Hash>} - A promise that resolves hash of the executed user operation.
      * @throws {Error} - Throws an error if the EVM broadcast fails, including the error message for debugging.
      */
-    broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
-        signature: Hex;
-        opHash: Hash;
-    }>;
+    broadcastBundler(chainId: number, signatureHex: Hex, unsignedUserOp: UserOperation): Promise<Hash>;
     /**
      * Executes a user operation on the specified blockchain network.
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).

package/dist/esm/near-safe.js

@@ -1,5 +1,5 @@
-import { setupAdapter, signatureFromOutcome, toPayload, requestRouter as mpcRequestRouter, } from "near-ca";
-import { serializeSignature, zeroAddress } from "viem";
+import { setupAdapter, toPayload, requestRouter as mpcRequestRouter, } from "near-ca";
+import { zeroAddress } from "viem";
 import { DEFAULT_SAFE_SALT_NONCE } from "./constants";
 import { Erc4337Bundler } from "./lib/bundler";
 import { encodeMulti } from "./lib/multisend";
@@ -153,24 +153,20 @@ export class NearSafe {
      * Warning: Uses a private ethRPC with sensitive Pimlico API key (should be run server side).
      *
      * @param {number} chainId - The ID of the EVM network to which the transaction should be broadcasted.
-     * @param {FinalExecutionOutcome} outcome - The result of the NEAR transaction execution, which contains the necessary data to construct an EVM signature.
+     * @param {Signature} signature - The valid signature of the unsignedUserOp.
      * @param {UserOperation} unsignedUserOp - The unsigned user operation to be broadcasted. This includes transaction data such as the destination address and data payload.
-     * @returns {Promise<{ signature: Hex; opHash: Hash }>} - A promise that resolves to an object containing the signature used and the hash of the executed user operation.
+     * @returns {Promise<Hash>} - A promise that resolves hash of the executed user operation.
      * @throws {Error} - Throws an error if the EVM broadcast fails, including the error message for debugging.
      */
-    async broadcastEvm(chainId, outcome, unsignedUserOp) {
-        const signature = packSignature(serializeSignature(signatureFromOutcome(outcome)));
+    async broadcastBundler(chainId, signatureHex, unsignedUserOp) {
         try {
-            return {
-                signature,
-                opHash: await this.executeTransaction(chainId, {
-                    ...unsignedUserOp,
-                    signature,
-                }),
-            };
+            return this.executeTransaction(chainId, {
+                ...unsignedUserOp,
+                signature: packSignature(signatureHex),
+            });
         }
         catch (error) {
-            throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Failed Bundler broadcast: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "license": "MIT",
   "description": "An SDK for controlling Ethereum Smart Accounts via ERC4337 from a Near Account.",
   "author": "bh2smith",
@@ -42,7 +42,6 @@
   },
   "dependencies": {
     "@safe-global/safe-gateway-typescript-sdk": "^3.22.2",
-    "ethers-multisend": "^3.1.0",
     "near-api-js": "^5.0.0",
     "near-ca": "^0.6.0",
     "semver": "^7.6.3",
@@ -61,6 +60,7 @@
     "eslint": "^9.6.0",
     "eslint-plugin-import": "^2.30.0",
     "ethers": "^6.13.1",
+    "ethers-multisend": "^3.1.0",
     "jest": "^29.7.0",
     "prettier": "^3.3.2",
     "ts-jest": "^29.1.5",