near-safe 0.8.5-beta.0 → 0.8.6

package/dist/cjs/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const USER_OP_IDENTIFIER: `0x${string}`;
 export declare const DEFAULT_SAFE_SALT_NONCE: string;
 export declare const SENTINEL_OWNERS = "0x0000000000000000000000000000000000000001";
+export declare const DEFAULT_SETUP_RPC = "https://ethereum-sepolia-rpc.publicnode.com";

package/dist/cjs/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SENTINEL_OWNERS = exports.DEFAULT_SAFE_SALT_NONCE = exports.USER_OP_IDENTIFIER = void 0;
+exports.DEFAULT_SETUP_RPC = 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
@@ -8,3 +8,4 @@ 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";
+exports.DEFAULT_SETUP_RPC = "https://ethereum-sepolia-rpc.publicnode.com";

package/dist/cjs/decode/util.js

@@ -4,7 +4,6 @@ exports.decodeTransactionSerializable = decodeTransactionSerializable;
 exports.decodeRlpHex = decodeRlpHex;
 exports.decodeTypedData = decodeTypedData;
 exports.decodeUserOperation = decodeUserOperation;
-const decodeMulti_1 = require("ethers-multisend/build/cjs/decodeMulti");
 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, decodeMulti_1.decodeMulti)(args[2])
+        ? (0, multisend_1.decodeMulti)(args[2])
         : [
             {
                 to: args[0],

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

@@ -3,4 +3,4 @@ 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 decodeMultiViem(data: Hex): MetaTransaction[];
+export declare function decodeMulti(data: Hex): MetaTransaction[];

package/dist/cjs/lib/multisend.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MULTI_SEND_ABI = void 0;
 exports.encodeMulti = encodeMulti;
 exports.isMultisendTx = isMultisendTx;
-exports.decodeMultiViem = decodeMultiViem;
+exports.decodeMulti = decodeMulti;
 const viem_1 = require("viem");
 const types_1 = require("../types");
 exports.MULTI_SEND_ABI = ["function multiSend(bytes memory transactions)"];
@@ -45,9 +45,6 @@ function isMultisendTx(args) {
     return (to === MULTISEND_141.toLowerCase() ||
         to === MULTISEND_CALLONLY_141.toLowerCase());
 }
-// import { Interface } from '@ethersproject/abi';
-// import { getAddress } from '@ethersproject/address';
-// import { BigNumber } from '@ethersproject/bignumber';
 function unpack(packed, startIndex) {
     // read operation from first 8 bits (= 2 hex digits)
     const operation = parseInt(packed.substring(startIndex, startIndex + 2), 16);
@@ -67,16 +64,9 @@ function unpack(packed, startIndex) {
         endIndex,
     };
 }
-function decodeMultiViem(data) {
-    // const multiSendContract = new Interface(MULTI_SEND_ABI);
-    // const tx = multiSendContract.parseTransaction({ data });
-    // const multiSendAbiItem = parseAbiItem({
-    //   type: "function",
-    //   name: "multiSend",
-    //   inputs: [{ name: "data", type: "bytes" }],
-    // });
+function decodeMulti(data) {
     const tx = (0, viem_1.decodeFunctionData)({
-        abi: exports.MULTI_SEND_ABI,
+        abi: (0, viem_1.parseAbi)(exports.MULTI_SEND_ABI),
         data,
     });
     const [transactionsEncoded] = tx.args;

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

@@ -4,13 +4,13 @@ import { Deployment, GasPrice, MetaTransaction, UnsignedUserOperation, UserOpera
  * All contracts used in account creation & execution
  */
 export declare class SafeContractSuite {
-    dummyClient: PublicClient;
+    setupClient: PublicClient;
     singleton: Deployment;
     proxyFactory: Deployment;
     m4337: Deployment;
     moduleSetup: Deployment;
     entryPoint: Deployment;
-    constructor();
+    constructor(rpcUrl?: string);
     addressForSetup(setup: Hex, saltNonce: string): Promise<Address>;
     getSetup(owners: string[]): Hex;
     addOwnerData(newOwner: Address): Hex;

package/dist/cjs/lib/safe.js

@@ -9,8 +9,8 @@ const util_1 = require("../util");
  * All contracts used in account creation & execution
  */
 class SafeContractSuite {
-    constructor() {
-        this.dummyClient = (0, util_1.getClient)(11155111);
+    constructor(rpcUrl = constants_1.DEFAULT_SETUP_RPC) {
+        this.setupClient = (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)(rpcUrl) });
         const deployments = deployments_1.SAFE_DEPLOYMENTS;
         this.singleton = deployments.singleton;
         this.proxyFactory = deployments.proxyFactory;
@@ -25,7 +25,7 @@ class SafeContractSuite {
         // abi.encodePacked(type(SafeProxy).creationCode, uint256(uint160(_singleton)));
         // cf: https://github.com/safe-global/safe-smart-account/blob/499b17ad0191b575fcadc5cb5b8e3faeae5391ae/contracts/proxies/SafeProxyFactory.sol#L29
         const initCode = (0, viem_1.encodePacked)(["bytes", "uint256"], [
-            (await this.dummyClient.readContract({
+            (await this.setupClient.readContract({
                 address: this.proxyFactory.address,
                 abi: this.proxyFactory.abi,
                 functionName: "proxyCreationCode",

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

@@ -1,16 +1,12 @@
-import { NearConfig } from "near-api-js/lib/near";
-import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, SignRequestData, EncodedSignRequest } from "near-ca";
+import { NearEthAdapter, SignRequestData, EncodedSignRequest, SetupConfig as MpcConfig } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { SafeContractSuite } from "./lib/safe";
 import { EncodedTxData, MetaTransaction, SponsorshipPolicyData, UserOperation, UserOperationReceipt } from "./types";
 export interface NearSafeConfig {
-    accountId: string;
-    mpcContractId: string;
-    nearConfig?: NearConfig;
-    privateKey?: string;
+    mpc: MpcConfig;
     pimlicoKey: string;
     safeSaltNonce?: string;
+    setupRpc?: string;
 }
 export declare class NearSafe {
     readonly nearAdapter: NearEthAdapter;
@@ -99,15 +95,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

@@ -17,11 +17,11 @@ class NearSafe {
      * @returns {Promise<NearSafe>} - A promise that resolves to a new `NearSafe` instance.
      */
     static async create(config) {
-        const { pimlicoKey } = config;
+        const { pimlicoKey, setupRpc } = config;
         const safeSaltNonce = config.safeSaltNonce || constants_1.DEFAULT_SAFE_SALT_NONCE;
         // const nearAdapter = await mockAdapter();
-        const nearAdapter = await (0, near_ca_1.setupAdapter)({ ...config });
-        const safePack = new safe_1.SafeContractSuite();
+        const nearAdapter = await (0, near_ca_1.setupAdapter)(config.mpc);
+        const safePack = new safe_1.SafeContractSuite(setupRpc);
         const setup = safePack.getSetup([nearAdapter.address]);
         const safeAddress = await safePack.addressForSetup(setup, safeSaltNonce);
         console.log(`
@@ -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/cjs/util.js

@@ -13,6 +13,7 @@ exports.raceToFirstResolve = raceToFirstResolve;
 exports.assertUnique = assertUnique;
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
+const constants_1 = require("./constants");
 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;
@@ -36,6 +37,10 @@ async function isContract(address, chainId) {
     return (await getClient(chainId).getCode({ address })) !== undefined;
 }
 function getClient(chainId) {
+    // TODO(bh2smith)
+    if (chainId === 11155111) {
+        return (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)(constants_1.DEFAULT_SETUP_RPC) });
+    }
     return near_ca_1.Network.fromChainId(chainId).client;
 }
 function metaTransactionsFromRequest(params) {

package/dist/esm/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const USER_OP_IDENTIFIER: `0x${string}`;
 export declare const DEFAULT_SAFE_SALT_NONCE: string;
 export declare const SENTINEL_OWNERS = "0x0000000000000000000000000000000000000001";
+export declare const DEFAULT_SETUP_RPC = "https://ethereum-sepolia-rpc.publicnode.com";

package/dist/esm/constants.js

@@ -5,3 +5,4 @@ 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";
+export const DEFAULT_SETUP_RPC = "https://ethereum-sepolia-rpc.publicnode.com";

package/dist/esm/decode/util.js

@@ -1,7 +1,6 @@
-import { decodeMulti } from "ethers-multisend/build/cjs/decodeMulti";
 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

@@ -3,4 +3,4 @@ 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 decodeMultiViem(data: Hex): MetaTransaction[];
+export declare function decodeMulti(data: Hex): MetaTransaction[];

package/dist/esm/lib/multisend.js

@@ -39,9 +39,6 @@ export function isMultisendTx(args) {
     return (to === MULTISEND_141.toLowerCase() ||
         to === MULTISEND_CALLONLY_141.toLowerCase());
 }
-// import { Interface } from '@ethersproject/abi';
-// import { getAddress } from '@ethersproject/address';
-// import { BigNumber } from '@ethersproject/bignumber';
 function unpack(packed, startIndex) {
     // read operation from first 8 bits (= 2 hex digits)
     const operation = parseInt(packed.substring(startIndex, startIndex + 2), 16);
@@ -61,16 +58,9 @@ function unpack(packed, startIndex) {
         endIndex,
     };
 }
-export function decodeMultiViem(data) {
-    // const multiSendContract = new Interface(MULTI_SEND_ABI);
-    // const tx = multiSendContract.parseTransaction({ data });
-    // const multiSendAbiItem = parseAbiItem({
-    //   type: "function",
-    //   name: "multiSend",
-    //   inputs: [{ name: "data", type: "bytes" }],
-    // });
+export function decodeMulti(data) {
     const tx = decodeFunctionData({
-        abi: MULTI_SEND_ABI,
+        abi: parseAbi(MULTI_SEND_ABI),
         data,
     });
     const [transactionsEncoded] = tx.args;

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

@@ -4,13 +4,13 @@ import { Deployment, GasPrice, MetaTransaction, UnsignedUserOperation, UserOpera
  * All contracts used in account creation & execution
  */
 export declare class SafeContractSuite {
-    dummyClient: PublicClient;
+    setupClient: PublicClient;
     singleton: Deployment;
     proxyFactory: Deployment;
     m4337: Deployment;
     moduleSetup: Deployment;
     entryPoint: Deployment;
-    constructor();
+    constructor(rpcUrl?: string);
     addressForSetup(setup: Hex, saltNonce: string): Promise<Address>;
     getSetup(owners: string[]): Hex;
     addOwnerData(newOwner: Address): Hex;

package/dist/esm/lib/safe.js

@@ -1,20 +1,20 @@
-import { concat, encodeFunctionData, encodePacked, getAddress, getCreate2Address, keccak256, parseAbi, toHex, zeroAddress, } from "viem";
+import { concat, createPublicClient, encodeFunctionData, encodePacked, getAddress, getCreate2Address, http, keccak256, parseAbi, toHex, zeroAddress, } from "viem";
 import { SAFE_DEPLOYMENTS } from "../_gen/deployments";
-import { SENTINEL_OWNERS, USER_OP_IDENTIFIER } from "../constants";
+import { DEFAULT_SETUP_RPC, SENTINEL_OWNERS, USER_OP_IDENTIFIER, } from "../constants";
 import { PLACEHOLDER_SIG, getClient, packGas, packPaymasterData, } from "../util";
 /**
  * All contracts used in account creation & execution
  */
 export class SafeContractSuite {
     // Used only for stateless contract reads.
-    dummyClient;
+    setupClient;
     singleton;
     proxyFactory;
     m4337;
     moduleSetup;
     entryPoint;
-    constructor() {
-        this.dummyClient = getClient(11155111);
+    constructor(rpcUrl = DEFAULT_SETUP_RPC) {
+        this.setupClient = createPublicClient({ transport: http(rpcUrl) });
         const deployments = SAFE_DEPLOYMENTS;
         this.singleton = deployments.singleton;
         this.proxyFactory = deployments.proxyFactory;
@@ -29,7 +29,7 @@ export class SafeContractSuite {
         // abi.encodePacked(type(SafeProxy).creationCode, uint256(uint160(_singleton)));
         // cf: https://github.com/safe-global/safe-smart-account/blob/499b17ad0191b575fcadc5cb5b8e3faeae5391ae/contracts/proxies/SafeProxyFactory.sol#L29
         const initCode = encodePacked(["bytes", "uint256"], [
-            (await this.dummyClient.readContract({
+            (await this.setupClient.readContract({
                 address: this.proxyFactory.address,
                 abi: this.proxyFactory.abi,
                 functionName: "proxyCreationCode",

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

@@ -1,16 +1,12 @@
-import { NearConfig } from "near-api-js/lib/near";
-import { FinalExecutionOutcome } from "near-api-js/lib/providers";
-import { NearEthAdapter, SignRequestData, EncodedSignRequest } from "near-ca";
+import { NearEthAdapter, SignRequestData, EncodedSignRequest, SetupConfig as MpcConfig } from "near-ca";
 import { Address, Hash, Hex } from "viem";
 import { SafeContractSuite } from "./lib/safe";
 import { EncodedTxData, MetaTransaction, SponsorshipPolicyData, UserOperation, UserOperationReceipt } from "./types";
 export interface NearSafeConfig {
-    accountId: string;
-    mpcContractId: string;
-    nearConfig?: NearConfig;
-    privateKey?: string;
+    mpc: MpcConfig;
     pimlicoKey: string;
     safeSaltNonce?: string;
+    setupRpc?: string;
 }
 export declare class NearSafe {
     readonly nearAdapter: NearEthAdapter;
@@ -99,15 +95,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";
@@ -20,11 +20,11 @@ export class NearSafe {
      * @returns {Promise<NearSafe>} - A promise that resolves to a new `NearSafe` instance.
      */
     static async create(config) {
-        const { pimlicoKey } = config;
+        const { pimlicoKey, setupRpc } = config;
         const safeSaltNonce = config.safeSaltNonce || DEFAULT_SAFE_SALT_NONCE;
         // const nearAdapter = await mockAdapter();
-        const nearAdapter = await setupAdapter({ ...config });
-        const safePack = new SafeContractSuite();
+        const nearAdapter = await setupAdapter(config.mpc);
+        const safePack = new SafeContractSuite(setupRpc);
         const setup = safePack.getSetup([nearAdapter.address]);
         const safeAddress = await safePack.addressForSetup(setup, safeSaltNonce);
         console.log(`
@@ -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/dist/esm/util.js

@@ -1,5 +1,6 @@
 import { getNetworkId, Network, signatureFromTxHash as sigFromHash, } from "near-ca";
-import { concatHex, encodePacked, toHex, isHex, parseTransaction, zeroAddress, toBytes, keccak256, serializeSignature, } from "viem";
+import { concatHex, encodePacked, toHex, isHex, parseTransaction, zeroAddress, toBytes, keccak256, serializeSignature, createPublicClient, http, } from "viem";
+import { DEFAULT_SETUP_RPC } from "./constants";
 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) {
@@ -22,6 +23,10 @@ export async function isContract(address, chainId) {
     return (await getClient(chainId).getCode({ address })) !== undefined;
 }
 export function getClient(chainId) {
+    // TODO(bh2smith)
+    if (chainId === 11155111) {
+        return createPublicClient({ transport: http(DEFAULT_SETUP_RPC) });
+    }
     return Network.fromChainId(chainId).client;
 }
 export function metaTransactionsFromRequest(params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "near-safe",
-  "version": "0.8.5-beta.0",
+  "version": "0.8.6",
   "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",