near-safe 0.3.1 → 0.4.0

package/dist/cjs/{index.d.ts → src/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 → src/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/{esm → cjs/src}/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 → src/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 → src/lib}/safe-message.d.ts

@@ -1,6 +1,6 @@
 import { type SafeInfo } from "@safe-global/safe-gateway-typescript-sdk";
-import { EIP712TypedData, RecoveryData } from "near-ca";
-import { Address, Hash } from "viem";
+import { EIP712TypedData } from "near-ca";
+import { Hash } from "viem";
 export type DecodedSafeMessage = {
     decodedMessage: string | EIP712TypedData;
     safeMessageMessage: string;
@@ -20,8 +20,3 @@ export type MinimalSafeInfo = Pick<SafeInfo, "address" | "version" | "chainId">;
  * }`
  */
 export declare function decodeSafeMessage(message: string | EIP712TypedData, safe: MinimalSafeInfo): DecodedSafeMessage;
-export declare function safeMessageTxData(method: string, message: DecodedSafeMessage, sender: Address): {
-    evmMessage: string;
-    payload: number[];
-    recoveryData: RecoveryData;
-};

package/dist/cjs/{lib → src/lib}/safe-message.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeSafeMessage = decodeSafeMessage;
-exports.safeMessageTxData = safeMessageTxData;
-const near_ca_1 = require("near-ca");
 const semver_1 = require("semver");
 const viem_1 = require("viem");
 /*
@@ -84,21 +82,6 @@ function decodeSafeMessage(message, safe) {
         safeMessageHash: generateSafeMessageHash(safe, decodedMessage),
     };
 }
-function safeMessageTxData(method, message, sender) {
-    return {
-        evmMessage: message.safeMessageMessage,
-        payload: (0, near_ca_1.toPayload)(message.safeMessageHash),
-        recoveryData: {
-            type: method,
-            data: {
-                address: sender,
-                // TODO - Upgrade Signable Message in near-ca
-                // @ts-expect-error: Type 'string | EIP712TypedData' is not assignable to type 'SignableMessage'.
-                message: decodedMessage,
-            },
-        },
-    };
-}
 // const isEIP712TypedData = (obj: any): obj is EIP712TypedData => {
 //   return (
 //     typeof obj === "object" &&

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

@@ -0,0 +1,21 @@
+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 SafeContractSuite {
+    dummyClient: PublicClient;
+    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;
+    getOpHash(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>;
+}

package/dist/cjs/{lib → src/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 → src/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, NearEthTxData, RecoveryData } from "near-ca";
+import { NearEthAdapter, SignRequestData } from "near-ca";
 import { Address, Hash, Hex } from "viem";
-import { Erc4337Bundler } from "./lib/bundler";
-import { ContractSuite } from "./lib/safe";
-import { MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
-export declare class TransactionManager {
+import { SafeContractSuite } from "./lib/safe";
+import { EncodedTxData, MetaTransaction, UserOperation, UserOperationReceipt } from "./types";
+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[];
@@ -31,15 +31,16 @@ export declare class TransactionManager {
     }): Promise<UserOperation>;
     signTransaction(safeOpHash: Hex): Promise<Hex>;
     opHash(userOp: UserOperation): Promise<Hash>;
-    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<NearEthTxData>;
-    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>;
+    encodeSignRequest(signRequest: SignRequestData, usePaymaster: boolean): Promise<EncodedTxData>;
     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.
      *
@@ -53,6 +54,6 @@ export declare class TransactionManager {
     requestRouter({ method, chainId, params }: SignRequestData, usePaymaster: boolean): Promise<{
         evmMessage: string;
         payload: number[];
-        recoveryData: RecoveryData;
+        hash: Hash;
     }>;
 }

package/dist/cjs/{tx-manager.js → src/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) {
@@ -68,16 +66,35 @@ class TransactionManager {
         return this.safePack.getOpHash(userOp);
     }
     async encodeSignRequest(signRequest, usePaymaster) {
-        const data = await this.requestRouter(signRequest, usePaymaster);
+        const { payload, evmMessage, hash } = await this.requestRouter(signRequest, usePaymaster);
         return {
             nearPayload: await this.nearAdapter.mpcContract.encodeSignatureRequestTx({
                 path: this.nearAdapter.derivationPath,
-                payload: data.payload,
+                payload,
                 key_version: 0,
             }),
-            ...data,
+            evmData: {
+                chainId: signRequest.chainId,
+                data: evmMessage,
+                hash,
+            },
         };
     }
+    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);
@@ -89,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 {
@@ -106,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.
@@ -152,12 +149,22 @@ class TransactionManager {
             case "eth_signTypedData":
             case "eth_signTypedData_v4":
             case "eth_sign": {
-                const [sender, messageOrData] = params;
-                return (0, safe_message_1.safeMessageTxData)(method, (0, safe_message_1.decodeSafeMessage)(messageOrData, safeInfo), sender);
+                const [_, messageOrData] = params;
+                const message = (0, safe_message_1.decodeSafeMessage)(messageOrData, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: (0, near_ca_1.toPayload)(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
             }
             case "personal_sign": {
-                const [messageHash, sender] = params;
-                return (0, safe_message_1.safeMessageTxData)(method, (0, safe_message_1.decodeSafeMessage)(messageHash, safeInfo), sender);
+                const [messageHash, _] = params;
+                const message = (0, safe_message_1.decodeSafeMessage)(messageHash, safeInfo);
+                return {
+                    evmMessage: message.safeMessageMessage,
+                    payload: (0, near_ca_1.toPayload)(message.safeMessageHash),
+                    hash: message.safeMessageHash,
+                };
             }
             case "eth_sendTransaction": {
                 const transactions = (0, util_1.metaTransactionsFromRequest)(params);
@@ -170,15 +177,10 @@ class TransactionManager {
                 return {
                     payload: (0, near_ca_1.toPayload)(opHash),
                     evmMessage: JSON.stringify(userOp),
-                    recoveryData: {
-                        type: method,
-                        // TODO: Double check that this is sufficient for UI.
-                        // We may want to adapt and return the `MetaTransactions` instead.
-                        data: opHash,
-                    },
+                    hash: await this.opHash(userOp),
                 };
             }
         }
     }
 }
-exports.TransactionManager = TransactionManager;
+exports.NearSafe = NearSafe;

package/dist/cjs/{types.d.ts → src/types.d.ts}

@@ -1,4 +1,16 @@
-import { Address, Hex } from "viem";
+import { FunctionCallTransaction, SignArgs } from "near-ca";
+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;
@@ -89,4 +101,14 @@ export interface MetaTransaction {
     readonly data: string;
     readonly operation?: OperationType;
 }
+export interface EncodedTxData {
+    evmData: {
+        chainId: number;
+        data: string | TransactionSerializable;
+        hash: Hash;
+    };
+    nearPayload: FunctionCallTransaction<{
+        request: SignArgs;
+    }>;
+}
 export {};

package/dist/esm/scripts/fetch-deployments.d.ts

@@ -0,0 +1,17 @@
+import { Deployment, SafeDeployments } from "../src/types";
+export declare const SAFE_VERSION = "1.4.1";
+export declare const MODULE_VERSION = "0.3.0";
+type DeploymentFn = (filter?: {
+    version: string;
+}) => {
+    networkAddresses: {
+        [chainId: string]: string;
+    };
+    abi: unknown[];
+} | undefined;
+type DeploymentArgs = {
+    version: string;
+};
+export declare function getDeployment(fn: DeploymentFn, { version }: DeploymentArgs): Promise<Deployment>;
+export declare function fetchDeployments(safeVersion?: string, moduleVersion?: string): Promise<SafeDeployments>;
+export {};

package/dist/esm/scripts/fetch-deployments.js

@@ -0,0 +1,54 @@
+import { getProxyFactoryDeployment, getSafeL2SingletonDeployment, } from "@safe-global/safe-deployments";
+import { getSafe4337ModuleDeployment, getSafeModuleSetupDeployment, } from "@safe-global/safe-modules-deployments";
+import { parseAbi } from "viem";
+import { getClient } from "../src/util";
+// Define the deployment version and chain ID (e.g., "1.4.1" for Safe contracts, "0.3.0" for modules)
+export const SAFE_VERSION = "1.4.1";
+export const MODULE_VERSION = "0.3.0";
+export 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,
+    };
+}
+export async function fetchDeployments(safeVersion = SAFE_VERSION, moduleVersion = MODULE_VERSION) {
+    console.log("Fetching deployments...");
+    const safeDeployment = async (fn) => getDeployment(fn, { version: safeVersion });
+    const m4337Deployment = async (fn) => getDeployment(fn, { version: moduleVersion });
+    try {
+        // Fetch deployments for Safe and 4337 modules
+        const [singleton, proxyFactory, moduleSetup, m4337] = await Promise.all([
+            safeDeployment(getSafeL2SingletonDeployment),
+            safeDeployment(getProxyFactoryDeployment),
+            m4337Deployment(getSafeModuleSetupDeployment),
+            m4337Deployment(getSafe4337ModuleDeployment),
+        ]);
+        // TODO - this is a cheeky hack.
+        const client = getClient(11155111);
+        const entryPoint = {
+            address: (await client.readContract({
+                address: m4337.address,
+                abi: m4337.abi,
+                functionName: "SUPPORTED_ENTRYPOINT",
+            })),
+            abi: parseAbi([
+                "function getNonce(address, uint192 key) view returns (uint256 nonce)",
+            ]),
+        };
+        return {
+            singleton,
+            proxyFactory,
+            moduleSetup,
+            m4337,
+            entryPoint,
+        };
+    }
+    catch (error) {
+        throw new Error(`Error fetching deployments: ${error}`);
+    }
+}

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

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