near-safe 0.2.0 → 0.3.0

package/dist/cjs/tx-manager.js

@@ -2,53 +2,60 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionManager = void 0;
 const near_ca_1 = require("near-ca");
+const viem_1 = require("viem");
 const bundler_1 = require("./lib/bundler");
-const util_1 = require("./util");
-const ethers_multisend_1 = require("ethers-multisend");
+const multisend_1 = require("./lib/multisend");
 const safe_1 = require("./lib/safe");
+const util_1 = require("./util");
 class TransactionManager {
-    constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, entryPointAddress, safeSaltNonce) {
+    constructor(nearAdapter, safePack, pimlicoKey, setup, safeAddress, safeSaltNonce) {
         this.nearAdapter = nearAdapter;
         this.safePack = safePack;
         this.pimlicoKey = pimlicoKey;
-        this.entryPointAddress = entryPointAddress;
         this.setup = setup;
         this.address = safeAddress;
         this.safeSaltNonce = safeSaltNonce;
         this.deployedChains = new Set();
     }
     static async create(config) {
-        const { nearAdapter, pimlicoKey } = config;
-        const safePack = await safe_1.ContractSuite.init();
+        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 = await safePack.getSetup([nearAdapter.address]);
+        const setup = safePack.getSetup([nearAdapter.address]);
         const safeAddress = await safePack.addressForSetup(setup, config.safeSaltNonce);
-        const entryPointAddress = (await safePack.entryPoint.getAddress());
         console.log(`Safe Address: ${safeAddress}`);
-        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, entryPointAddress, config.safeSaltNonce || "0");
+        return new TransactionManager(nearAdapter, safePack, pimlicoKey, setup, safeAddress, config.safeSaltNonce || "0");
     }
     get mpcAddress() {
         return this.nearAdapter.address;
     }
+    get mpcContractId() {
+        return this.nearAdapter.mpcContract.contract.contractId;
+    }
     async getBalance(chainId) {
-        const provider = near_ca_1.Network.fromChainId(chainId).client;
-        return await provider.getBalance({ address: this.address });
+        return await (0, util_1.getClient)(chainId).getBalance({ address: this.address });
     }
     bundlerForChainId(chainId) {
-        return new bundler_1.Erc4337Bundler(this.entryPointAddress, this.pimlicoKey, chainId);
+        return new bundler_1.Erc4337Bundler(this.safePack.entryPoint.address, this.pimlicoKey, chainId);
     }
     async buildTransaction(args) {
         const { transactions, usePaymaster, chainId } = args;
-        const bundler = this.bundlerForChainId(chainId);
-        const gasFees = (await bundler.getGasPrice()).fast;
-        // Build Singular MetaTransaction for Multisend from transaction list.
         if (transactions.length === 0) {
             throw new Error("Empty transaction set!");
         }
-        const tx = transactions.length > 1 ? (0, ethers_multisend_1.encodeMulti)(transactions) : transactions[0];
-        const safeNotDeployed = !(await this.safeDeployed(chainId));
-        const rawUserOp = await this.safePack.buildUserOp(tx, this.address, gasFees, this.setup, safeNotDeployed, this.safeSaltNonce);
-        const paymasterData = await bundler.getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed);
+        const bundler = this.bundlerForChainId(chainId);
+        const [gasFees, nonce, safeDeployed] = await Promise.all([
+            bundler.getGasPrice(),
+            this.safePack.getNonce(this.address, chainId),
+            this.safeDeployed(chainId),
+        ]);
+        // Build Singular MetaTransaction for Multisend from transaction list.
+        const tx = transactions.length > 1 ? (0, multisend_1.encodeMulti)(transactions) : transactions[0];
+        const rawUserOp = await this.safePack.buildUserOp(nonce, tx, this.address, gasFees.fast, this.setup, !safeDeployed, this.safeSaltNonce);
+        const paymasterData = await bundler.getPaymasterData(rawUserOp, usePaymaster, !safeDeployed);
         const unsignedUserOp = { ...rawUserOp, ...paymasterData };
         return unsignedUserOp;
     }
@@ -93,11 +100,11 @@ class TransactionManager {
         return userOpReceipt;
     }
     async safeDeployed(chainId) {
+        // Early exit if already known.
         if (chainId in this.deployedChains) {
             return true;
         }
-        const provider = near_ca_1.Network.fromChainId(chainId).client;
-        const deployed = (await provider.getCode({ address: this.address })) !== "0x";
+        const deployed = await (0, util_1.isContract)(this.address, chainId);
         if (deployed) {
             this.deployedChains.add(chainId);
         }
@@ -107,7 +114,7 @@ class TransactionManager {
         return {
             to: this.address,
             value: "0",
-            data: this.safePack.singleton.interface.encodeFunctionData("addOwnerWithThreshold", [address, 1]),
+            data: this.safePack.addOwnerData(address),
         };
     }
     async safeSufficientlyFunded(chainId, transactions, gasCost) {
@@ -118,5 +125,20 @@ class TransactionManager {
         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)}`);
+        }
+    }
 }
 exports.TransactionManager = TransactionManager;

package/dist/cjs/types.d.ts

@@ -79,4 +79,14 @@ export interface GasPrice {
     maxFeePerGas: Hex;
     maxPriorityFeePerGas: Hex;
 }
+export declare enum OperationType {
+    Call = 0,
+    DelegateCall = 1
+}
+export interface MetaTransaction {
+    readonly to: string;
+    readonly value: string;
+    readonly data: string;
+    readonly operation?: OperationType;
+}
 export {};

package/dist/cjs/types.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationType = void 0;
+var OperationType;
+(function (OperationType) {
+    OperationType[OperationType["Call"] = 0] = "Call";
+    OperationType[OperationType["DelegateCall"] = 1] = "DelegateCall";
+})(OperationType || (exports.OperationType = OperationType = {}));

package/dist/cjs/util.d.ts

@@ -1,10 +1,11 @@
-import { PaymasterData } from "./types.js";
-import { MetaTransaction } from "ethers-multisend";
-import { Hex } from "viem";
+import { Address, Hex, PublicClient } from "viem";
+import { PaymasterData, MetaTransaction } from "./types";
 export declare const PLACEHOLDER_SIG: `0x${string}`;
 type IntLike = Hex | bigint | string | number;
 export declare const packGas: (hi: IntLike, lo: IntLike) => string;
 export declare function packSignature(signature: `0x${string}`, validFrom?: number, validTo?: number): Hex;
 export declare function packPaymasterData(data: PaymasterData): Hex;
 export declare function containsValue(transactions: MetaTransaction[]): boolean;
+export declare function isContract(address: Address, chainId: number): Promise<boolean>;
+export declare function getClient(chainId: number): PublicClient;
 export {};

package/dist/cjs/util.js

@@ -4,6 +4,9 @@ exports.packGas = exports.PLACEHOLDER_SIG = void 0;
 exports.packSignature = packSignature;
 exports.packPaymasterData = packPaymasterData;
 exports.containsValue = containsValue;
+exports.isContract = isContract;
+exports.getClient = getClient;
+const near_ca_1 = require("near-ca");
 const viem_1 = require("viem");
 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)]);
@@ -24,3 +27,9 @@ function packPaymasterData(data) {
 function containsValue(transactions) {
     return transactions.some((tx) => tx.value !== "0");
 }
+async function isContract(address, chainId) {
+    return (await getClient(chainId).getCode({ address })) !== undefined;
+}
+function getClient(chainId) {
+    return near_ca_1.Network.fromChainId(chainId).client;
+}

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

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

@@ -1,15 +1,37 @@
-import { ethers } from "ethers";
-import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types.js";
+import { Address, Hash, PublicClient, Transport } from "viem";
+import { GasPrices, PaymasterData, UnsignedUserOperation, UserOperation, UserOperationReceipt } from "../types";
+type BundlerRpcSchema = [
+    {
+        Method: "pm_sponsorUserOperation";
+        Parameters: [UnsignedUserOperation, Address];
+        ReturnType: PaymasterData;
+    },
+    {
+        Method: "eth_sendUserOperation";
+        Parameters: [UserOperation, Address];
+        ReturnType: Hash;
+    },
+    {
+        Method: "pimlico_getUserOperationGasPrice";
+        Parameters: [];
+        ReturnType: GasPrices;
+    },
+    {
+        Method: "eth_getUserOperationReceipt";
+        Parameters: [Hash];
+        ReturnType: UserOperationReceipt | null;
+    }
+];
 export declare class Erc4337Bundler {
-    provider: ethers.JsonRpcProvider;
-    entryPointAddress: string;
+    client: PublicClient<Transport, undefined, undefined, BundlerRpcSchema>;
+    entryPointAddress: Address;
     apiKey: string;
     chainId: number;
-    constructor(entryPointAddress: string, apiKey: string, chainId: number);
-    client(chainId: number): ethers.JsonRpcProvider;
+    constructor(entryPointAddress: Address, apiKey: string, chainId: number);
     getPaymasterData(rawUserOp: UnsignedUserOperation, usePaymaster: boolean, safeNotDeployed: boolean): Promise<PaymasterData>;
-    sendUserOperation(userOp: UserOperation): Promise<string>;
+    sendUserOperation(userOp: UserOperation): Promise<Hash>;
     getGasPrice(): Promise<GasPrices>;
-    _getUserOpReceiptInner(userOpHash: string): Promise<UserOperationReceipt | null>;
-    getUserOpReceipt(userOpHash: string): Promise<UserOperationReceipt>;
+    getUserOpReceipt(userOpHash: Hash): Promise<UserOperationReceipt>;
+    private _getUserOpReceiptInner;
 }
+export {};

package/dist/esm/lib/bundler.js

@@ -1,12 +1,10 @@
-// TODO: Ethers dependency is only for Generic HTTP Provider
-import { ethers } from "ethers";
-import { PLACEHOLDER_SIG } from "../util.js";
-import { toHex } from "viem";
+import { createPublicClient, http, rpcSchema, toHex, RpcError, HttpRequestError, } from "viem";
+import { PLACEHOLDER_SIG } from "../util";
 function bundlerUrl(chainId, apikey) {
     return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${apikey}`;
 }
 export class Erc4337Bundler {
-    provider;
+    client;
     entryPointAddress;
     apiKey;
     chainId;
@@ -14,41 +12,37 @@ export class Erc4337Bundler {
         this.entryPointAddress = entryPointAddress;
         this.apiKey = apiKey;
         this.chainId = chainId;
-        this.provider = new ethers.JsonRpcProvider(bundlerUrl(chainId, apiKey));
-    }
-    client(chainId) {
-        return new ethers.JsonRpcProvider(bundlerUrl(chainId, this.apiKey));
+        this.client = createPublicClient({
+            transport: http(bundlerUrl(chainId, this.apiKey)),
+            rpcSchema: rpcSchema(),
+        });
     }
     async getPaymasterData(rawUserOp, usePaymaster, safeNotDeployed) {
         // TODO: Keep this option out of the bundler
         if (usePaymaster) {
             console.log("Requesting paymaster data...");
-            const data = this.provider.send("pm_sponsorUserOperation", [
-                { ...rawUserOp, signature: PLACEHOLDER_SIG },
-                this.entryPointAddress,
-            ]);
-            return data;
+            return handleRequest(() => this.client.request({
+                method: "pm_sponsorUserOperation",
+                params: [
+                    { ...rawUserOp, signature: PLACEHOLDER_SIG },
+                    this.entryPointAddress,
+                ],
+            }));
         }
         return defaultPaymasterData(safeNotDeployed);
     }
     async sendUserOperation(userOp) {
-        try {
-            const userOpHash = await this.provider.send("eth_sendUserOperation", [
-                userOp,
-                this.entryPointAddress,
-            ]);
-            return userOpHash;
-        }
-        catch (err) {
-            const error = err.error;
-            throw new Error(`Failed to send user op with: ${error.message}`);
-        }
+        return handleRequest(() => this.client.request({
+            method: "eth_sendUserOperation",
+            params: [userOp, this.entryPointAddress],
+        }));
+        // throw new Error(`Failed to send user op with: ${error.message}`);
     }
     async getGasPrice() {
-        return this.provider.send("pimlico_getUserOperationGasPrice", []);
-    }
-    async _getUserOpReceiptInner(userOpHash) {
-        return this.provider.send("eth_getUserOperationReceipt", [userOpHash]);
+        return handleRequest(() => this.client.request({
+            method: "pimlico_getUserOperationGasPrice",
+            params: [],
+        }));
     }
     async getUserOpReceipt(userOpHash) {
         let userOpReceipt = null;
@@ -59,6 +53,31 @@ export class Erc4337Bundler {
         }
         return userOpReceipt;
     }
+    async _getUserOpReceiptInner(userOpHash) {
+        return handleRequest(() => this.client.request({
+            method: "eth_getUserOperationReceipt",
+            params: [userOpHash],
+        }));
+    }
+}
+async function handleRequest(clientMethod) {
+    try {
+        return await clientMethod();
+    }
+    catch (error) {
+        if (error instanceof HttpRequestError) {
+            if (error.status === 401) {
+                throw new Error("Unauthorized request. Please check your API key.");
+            }
+            else {
+                console.error(`Request failed with status ${error.status}: ${error.message}`);
+            }
+        }
+        else if (error instanceof RpcError) {
+            throw new Error(`Failed to send user op with: ${error.message}`);
+        }
+        throw new Error(`Unexpected error ${error instanceof Error ? error.message : String(error)}`);
+    }
 }
 // TODO(bh2smith) Should probably get reasonable estimates here:
 const defaultPaymasterData = (safeNotDeployed) => {

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

@@ -0,0 +1,3 @@
+import { MetaTransaction } from "../types";
+export declare const MULTI_SEND_ABI: string[];
+export declare function encodeMulti(transactions: readonly MetaTransaction[], multiSendContractAddress?: string): MetaTransaction;

package/dist/esm/lib/multisend.js

@@ -0,0 +1,36 @@
+import { encodeFunctionData, encodePacked, parseAbi, size, } from "viem";
+import { OperationType } from "../types";
+export const MULTI_SEND_ABI = ["function multiSend(bytes memory transactions)"];
+const MULTISEND_141 = "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526";
+const MULTISEND_CALLONLY_141 = "0x9641d764fc13c8B624c04430C7356C1C7C8102e2";
+/// Encodes the transaction as packed bytes of:
+/// - `operation` as a `uint8` with `0` for a `call` or `1` for a `delegatecall` (=> 1 byte),
+/// - `to` as an `address` (=> 20 bytes),
+/// - `value` as a `uint256` (=> 32 bytes),
+/// -  length of `data` as a `uint256` (=> 32 bytes),
+/// - `data` as `bytes`.
+const encodeMetaTx = (tx) => encodePacked(["uint8", "address", "uint256", "uint256", "bytes"], [
+    tx.operation || OperationType.Call,
+    tx.to,
+    BigInt(tx.value),
+    BigInt(size(tx.data)),
+    tx.data,
+]);
+const remove0x = (hexString) => hexString.slice(2);
+// Encodes a batch of module transactions into a single multiSend module transaction.
+// A module transaction is an object with fields corresponding to a Gnosis Safe's (i.e., Zodiac IAvatar's) `execTransactionFromModule` method parameters.
+export function encodeMulti(transactions, multiSendContractAddress = transactions.some((t) => t.operation === OperationType.DelegateCall)
+    ? MULTISEND_141
+    : MULTISEND_CALLONLY_141) {
+    const encodedTransactions = "0x" + transactions.map(encodeMetaTx).map(remove0x).join("");
+    return {
+        operation: OperationType.DelegateCall,
+        to: multiSendContractAddress,
+        value: "0x00",
+        data: encodeFunctionData({
+            abi: parseAbi(MULTI_SEND_ABI),
+            functionName: "multiSend",
+            args: [encodedTransactions],
+        }),
+    };
+}

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

@@ -1,25 +1,27 @@
-import { ethers } from "ethers";
-import { GasPrice, UnsignedUserOperation, UserOperation } from "../types";
-import { MetaTransaction } from "ethers-multisend";
-import { Address, Hash, Hex } from "viem";
+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}`;
+}
 /**
  * All contracts used in account creation & execution
  */
 export declare class ContractSuite {
-    provider: ethers.JsonRpcProvider;
-    singleton: ethers.Contract;
-    proxyFactory: ethers.Contract;
-    m4337: ethers.Contract;
-    moduleSetup: ethers.Contract;
-    entryPoint: ethers.Contract;
-    constructor(provider: ethers.JsonRpcProvider, singleton: ethers.Contract, proxyFactory: ethers.Contract, m4337: ethers.Contract, moduleSetup: ethers.Contract, entryPoint: ethers.Contract);
+    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>;
-    addressForSetup(setup: ethers.BytesLike, saltNonce?: string): Promise<Address>;
-    getSetup(owners: string[]): Promise<Hex>;
+    addressForSetup(setup: Hex, saltNonce?: string): Promise<Address>;
+    getSetup(owners: string[]): Hex;
+    addOwnerData(newOwner: Address): Hex;
     getOpHash(unsignedUserOp: UserOperation): Promise<Hash>;
-    factoryDataForSetup(safeNotDeployed: boolean, setup: string, safeSaltNonce: string): {
-        factory?: Address;
-        factoryData?: Hex;
-    };
-    buildUserOp(txData: MetaTransaction, safeAddress: Address, feeData: GasPrice, setup: string, safeNotDeployed: boolean, safeSaltNonce: string): Promise<UnsignedUserOperation>;
+    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>;
 }
+export {};