near-safe 0.3.2 → 0.4.1

package/dist/cjs/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./tx-manager";
+export * from "./near-safe";
 export * from "./types";
 export * from "./util";
 export { Network, BaseTx, SignRequestData, populateTx } from "near-ca";

package/dist/cjs/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.populateTx = exports.Network = void 0;
-__exportStar(require("./tx-manager"), exports);
+__exportStar(require("./near-safe"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./util"), exports);
 var near_ca_1 = require("near-ca");

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

@@ -34,4 +34,5 @@ export declare class Erc4337Bundler {
     getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;
     private _getUserOpReceiptInner;
 }
+export declare function stripApiKey(error: unknown): string;
 export {};

package/dist/cjs/lib/bundler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Erc4337Bundler = void 0;
+exports.stripApiKey = stripApiKey;
 const viem_1 = require("viem");
 const util_1 = require("../util");
 function bundlerUrl(chainId, apikey) {
@@ -65,18 +66,19 @@ async function handleRequest(clientMethod) {
         return await clientMethod();
     }
     catch (error) {
+        const message = stripApiKey(error);
         if (error instanceof viem_1.HttpRequestError) {
             if (error.status === 401) {
-                throw new Error("Unauthorized request. Please check your API key.");
+                throw new Error("Unauthorized request. Please check your Pimlico API key.");
             }
             else {
-                console.error(`Request failed with status ${error.status}: ${error.message}`);
+                throw new Error(`Pimlico: ${message}`);
             }
         }
         else if (error instanceof viem_1.RpcError) {
-            throw new Error(`Failed to send user op with: ${error.message}`);
+            throw new Error(`Failed to send user op with: ${message}`);
         }
-        throw new Error(`Unexpected error ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Bundler Request: ${message}`);
     }
 }
 // TODO(bh2smith) Should probably get reasonable estimates here:
@@ -87,3 +89,12 @@ const defaultPaymasterData = (safeNotDeployed) => {
         preVerificationGas: (0, viem_1.toHex)(100000),
     };
 };
+function stripApiKey(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/(apikey=)[^\s&]+/, "$1***");
+    // Could also do this with slicing.
+    // const keyStart = message.indexOf("apikey=") + 7;
+    // // If no apikey in the message, return it as is.
+    // if (keyStart === -1) return message;
+    // return `${message.slice(0, keyStart)}***${message.slice(keyStart + 36)}`;
+}

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

@@ -1,21 +1,16 @@
-import { Address, Hash, Hex, ParseAbi, PublicClient } from "viem";
-import { GasPrice, MetaTransaction, UnsignedUserOperation, UserOperation } from "../types";
-interface DeploymentData {
-    abi: unknown[] | ParseAbi<readonly string[]>;
-    address: `0x${string}`;
-}
+import { Address, Hash, Hex, PublicClient } from "viem";
+import { Deployment, GasPrice, MetaTransaction, UnsignedUserOperation, UserOperation } from "../types";
 /**
  * All contracts used in account creation & execution
  */
-export declare class ContractSuite {
+export declare class SafeContractSuite {
     dummyClient: PublicClient;
-    singleton: DeploymentData;
-    proxyFactory: DeploymentData;
-    m4337: DeploymentData;
-    moduleSetup: DeploymentData;
-    entryPoint: DeploymentData;
-    constructor(client: PublicClient, singleton: DeploymentData, proxyFactory: DeploymentData, m4337: DeploymentData, moduleSetup: DeploymentData, entryPoint: DeploymentData);
-    static init(): Promise<ContractSuite>;
+    singleton: Deployment;
+    proxyFactory: Deployment;
+    m4337: Deployment;
+    moduleSetup: Deployment;
+    entryPoint: Deployment;
+    constructor();
     addressForSetup(setup: Hex, saltNonce?: string): Promise<Address>;
     getSetup(owners: string[]): Hex;
     addOwnerData(newOwner: Address): Hex;
@@ -24,4 +19,3 @@ export declare class ContractSuite {
     buildUserOp(nonce: bigint, txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
     getNonce(address: Address, chainId: number): Promise<bigint>;
 }
-export {};

package/dist/cjs/lib/safe.js

@@ -1,54 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContractSuite = void 0;
-const safe_deployments_1 = require("@safe-global/safe-deployments");
-const safe_modules_deployments_1 = require("@safe-global/safe-modules-deployments");
+exports.SafeContractSuite = void 0;
 const viem_1 = require("viem");
+const deployments_1 = require("../_gen/deployments");
 const util_1 = require("../util");
 /**
  * All contracts used in account creation & execution
  */
-class ContractSuite {
-    constructor(client, singleton, proxyFactory, m4337, moduleSetup, entryPoint) {
-        this.dummyClient = client;
-        this.singleton = singleton;
-        this.proxyFactory = proxyFactory;
-        this.m4337 = m4337;
-        this.moduleSetup = moduleSetup;
-        this.entryPoint = entryPoint;
-    }
-    static async init() {
-        // TODO - this is a cheeky hack.
-        const client = (0, util_1.getClient)(11155111);
-        const safeDeployment = (fn) => getDeployment(fn, { version: "1.4.1" });
-        const m4337Deployment = async (fn) => {
-            return getDeployment(fn, { version: "0.3.0" });
-        };
-        const [singleton, proxyFactory, moduleSetup, m4337] = await Promise.all([
-            safeDeployment(safe_deployments_1.getSafeL2SingletonDeployment),
-            safeDeployment(safe_deployments_1.getProxyFactoryDeployment),
-            m4337Deployment(safe_modules_deployments_1.getSafeModuleSetupDeployment),
-            m4337Deployment(safe_modules_deployments_1.getSafe4337ModuleDeployment),
-        ]);
-        // console.log("Initialized ERC4337 & Safe Module Contracts:", {
-        //   singleton: await singleton.getAddress(),
-        //   proxyFactory: await proxyFactory.getAddress(),
-        //   m4337: await m4337.getAddress(),
-        //   moduleSetup: await moduleSetup.getAddress(),
-        //   entryPoint: await entryPoint.getAddress(),
-        // });
-        return new ContractSuite(client, singleton, proxyFactory, m4337, moduleSetup, 
-        // EntryPoint:
-        {
-            address: (await client.readContract({
-                address: m4337.address,
-                abi: m4337.abi,
-                functionName: "SUPPORTED_ENTRYPOINT",
-            })),
-            abi: (0, viem_1.parseAbi)([
-                "function getNonce(address, uint192 key) view returns (uint256 nonce)",
-            ]),
-        });
+class SafeContractSuite {
+    constructor() {
+        this.dummyClient = (0, util_1.getClient)(11155111);
+        const deployments = deployments_1.SAFE_DEPLOYMENTS;
+        this.singleton = deployments.singleton;
+        this.proxyFactory = deployments.proxyFactory;
+        this.m4337 = deployments.m4337;
+        this.moduleSetup = deployments.moduleSetup;
+        this.entryPoint = deployments.entryPoint;
     }
     async addressForSetup(setup, saltNonce) {
         // bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
@@ -159,15 +126,4 @@ class ContractSuite {
         return nonce;
     }
 }
-exports.ContractSuite = ContractSuite;
-async function getDeployment(fn, { version }) {
-    const deployment = fn({ version });
-    if (!deployment) {
-        throw new Error(`Deployment not found for ${fn.name} version ${version}`);
-    }
-    // TODO: maybe call parseAbi on deployment.abi here.
-    return {
-        address: deployment.networkAddresses["11155111"],
-        abi: deployment.abi,
-    };
-}
+exports.SafeContractSuite = SafeContractSuite;

package/dist/cjs/{tx-manager.d.ts → near-safe.d.ts}

@@ -1,29 +1,29 @@
+import { NearConfig } from "near-api-js/lib/near";
 import { FinalExecutionOutcome } from "near-api-js/lib/providers";
 import { NearEthAdapter, SignRequestData } from "near-ca";
 import { Address, Hash, Hex } from "viem";
-import { Erc4337Bundler } from "./lib/bundler";
-import { ContractSuite } from "./lib/safe";
+import { SafeContractSuite } from "./lib/safe";
 import { EncodedTxData, MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
-export declare class TransactionManager {
+export interface NearSafeConfig {
+    accountId: string;
+    mpcContractId: string;
+    pimlicoKey: string;
+    nearConfig?: NearConfig;
+    privateKey?: string;
+    safeSaltNonce?: string;
+}
+export declare class NearSafe {
     readonly nearAdapter: NearEthAdapter;
     readonly address: Address;
     private safePack;
     private setup;
     private pimlicoKey;
     private safeSaltNonce;
-    private deployedChains;
-    constructor(nearAdapter: NearEthAdapter, safePack: ContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, safeSaltNonce: string);
-    static create(config: {
-        accountId: string;
-        mpcContractId: string;
-        pimlicoKey: string;
-        privateKey?: string;
-        safeSaltNonce?: string;
-    }): Promise<TransactionManager>;
+    static create(config: NearSafeConfig): Promise<NearSafe>;
+    constructor(nearAdapter: NearEthAdapter, safePack: SafeContractSuite, pimlicoKey: string, setup: string, safeAddress: Address, safeSaltNonce: string);
     get mpcAddress(): Address;
     get mpcContractId(): string;
     getBalance(chainId: number): Promise<bigint>;
-    bundlerForChainId(chainId: number): Erc4337Bundler;
     buildTransaction(args: {
         chainId: number;
         transactions: MetaTransaction[];
@@ -32,14 +32,15 @@ export declare class TransactionManager {
     signTransaction(safeOpHash: Hex): Promise<Hex>;
     opHash(userOp: UserOperation): Promise<Hash>;
     encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
-    executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
-    safeDeployed(chainId: number): Promise<boolean>;
-    addOwnerTx(address: Address): MetaTransaction;
-    safeSufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
     broadcastEvm(chainId: number, outcome: FinalExecutionOutcome, unsignedUserOp: UserOperation): Promise<{
         signature: Hex;
         receipt: UserOperationReceipt;
     }>;
+    executeTransaction(chainId: number, userOp: UserOperation): Promise<UserOperationReceipt>;
+    safeDeployed(chainId: number): Promise<boolean>;
+    sufficientlyFunded(chainId: number, transactions: MetaTransaction[], gasCost: bigint): Promise<boolean>;
+    addOwnerTx(address: Address): MetaTransaction;
+    private bundlerForChainId;
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
      *

package/dist/cjs/{tx-manager.js → near-safe.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionManager = void 0;
+exports.NearSafe = void 0;
 const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
 const bundler_1 = require("./lib/bundler");
@@ -8,27 +8,28 @@ const multisend_1 = require("./lib/multisend");
 const safe_1 = require("./lib/safe");
 const safe_message_1 = require("./lib/safe-message");
 const util_1 = require("./util");
-class TransactionManager {
+class NearSafe {
+    static async create(config) {
+        const { pimlicoKey, safeSaltNonce } = config;
+        const nearAdapter = await (0, near_ca_1.setupAdapter)({ ...config });
+        const safePack = new safe_1.SafeContractSuite();
+        const setup = safePack.getSetup([nearAdapter.address]);
+        const safeAddress = await safePack.addressForSetup(setup, safeSaltNonce);
+        console.log(`
+      Near Adapter:
+        Near Account ID: ${nearAdapter.nearAccountId()}
+        MPC EOA: ${nearAdapter.address}
+        Safe: ${safeAddress}
+    `);
+        return new NearSafe(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce || "0");
+    }
     constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce) {
         this.nearAdapter = nearAdapter;
+        this.address = safeAddress;
+        this.setup = setup;
         this.safePack = safePack;
         this.pimlicoKey = pimlicoKey;
-        this.setup = setup;
-        this.address = safeAddress;
         this.safeSaltNonce = safeSaltNonce;
-        this.deployedChains = new Set();
-    }
-    static async create(config) {
-        const { pimlicoKey } = config;
-        const [nearAdapter, safePack] = await Promise.all([
-            (0, near_ca_1.setupAdapter)({ ...config }),
-            safe_1.ContractSuite.init(),
-        ]);
-        console.log(`Near Adapter: ${nearAdapter.nearAccountId()} <> ${nearAdapter.address}`);
-        const setup = safePack.getSetup([nearAdapter.address]);
-        const safeAddress = await safePack.addressForSetup(setup, config.safeSaltNonce);
-        console.log(`Safe Address: ${safeAddress}`);
-        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, config.safeSaltNonce || "0");
     }
     get mpcAddress() {
         return this.nearAdapter.address;
@@ -39,9 +40,6 @@ class TransactionManager {
     async getBalance(chainId) {
         return await (0, util_1.getClient)(chainId).getBalance({ address: this.address });
     }
-    bundlerForChainId(chainId) {
-        return new bundler_1.Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
-    }
     async buildTransaction(args) {
         const { transactions, usePaymaster, chainId } = args;
         if (transactions.length === 0) {
@@ -82,6 +80,21 @@ class TransactionManager {
             },
         };
     }
+    async broadcastEvm(chainId, outcome, unsignedUserOp) {
+        const signature = (0, util_1.packSignature)((0, viem_1.serializeSignature)((0, near_ca_1.signatureFromOutcome)(outcome)));
+        try {
+            return {
+                signature,
+                receipt: await this.executeTransaction(chainId, {
+                    ...unsignedUserOp,
+                    signature,
+                }),
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async executeTransaction(chainId, userOp) {
         const bundler = this.bundlerForChainId(chainId);
         const userOpHash = await bundler.sendUserOperation(userOp);
@@ -93,15 +106,15 @@ class TransactionManager {
         return userOpReceipt;
     }
     async safeDeployed(chainId) {
-        // Early exit if already known.
-        if (chainId in this.deployedChains) {
+        return (0, util_1.isContract)(this.address, chainId);
+    }
+    async sufficientlyFunded(chainId, transactions, gasCost) {
+        const txValue = transactions.reduce((acc, tx) => acc + BigInt(tx.value), 0n);
+        if (txValue + gasCost === 0n) {
             return true;
         }
-        const deployed = await (0, util_1.isContract)(this.address, chainId);
-        if (deployed) {
-            this.deployedChains.add(chainId);
-        }
-        return deployed;
+        const safeBalance = await this.getBalance(chainId);
+        return txValue + gasCost < safeBalance;
     }
     addOwnerTx(address) {
         return {
@@ -110,28 +123,8 @@ class TransactionManager {
             data: this.safePack.addOwnerData(address),
         };
     }
-    async safeSufficientlyFunded(chainId, transactions, gasCost) {
-        const txValue = transactions.reduce((acc, tx) => acc + BigInt(tx.value), 0n);
-        if (txValue + gasCost === 0n) {
-            return true;
-        }
-        const safeBalance = await this.getBalance(chainId);
-        return txValue + gasCost < safeBalance;
-    }
-    async broadcastEvm(chainId, outcome, unsignedUserOp) {
-        const signature = (0, util_1.packSignature)((0, viem_1.serializeSignature)((0, near_ca_1.signatureFromOutcome)(outcome)));
-        try {
-            return {
-                signature,
-                receipt: await this.executeTransaction(chainId, {
-                    ...unsignedUserOp,
-                    signature,
-                }),
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed EVM broadcast: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    bundlerForChainId(chainId) {
+        return new bundler_1.Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
     }
     /**
      * Handles routing of signature requests based on the provided method, chain ID, and parameters.
@@ -190,4 +183,4 @@ class TransactionManager {
         }
     }
 }
-exports.TransactionManager = TransactionManager;
+exports.NearSafe = NearSafe;

package/dist/cjs/types.d.ts

@@ -1,5 +1,16 @@
 import { FunctionCallTransaction, SignArgs } from "near-ca";
-import { Address, Hash, Hex, TransactionSerializable } from "viem";
+import { Address, Hash, Hex, ParseAbi, TransactionSerializable } from "viem";
+export type SafeDeployments = {
+    singleton: Deployment;
+    proxyFactory: Deployment;
+    moduleSetup: Deployment;
+    m4337: Deployment;
+    entryPoint: Deployment;
+};
+export interface Deployment {
+    abi: unknown[] | ParseAbi<readonly string[]>;
+    address: Address;
+}
 export interface UnsignedUserOperation {
     sender: Address;
     nonce: string;

package/dist/esm/_gen/deployments.d.ts

@@ -0,0 +1,2 @@
+import { SafeDeployments } from "../types";
+export declare const SAFE_DEPLOYMENTS: SafeDeployments;