permissionless 0.0.6 → 0.0.8

package/actions/pimlico.ts

@@ -1,252 +1,35 @@
-import type { Address, Client, Hash, Hex } from "viem"
-import type { PartialBy } from "viem/types/utils"
-import type { PimlicoBundlerClient, PimlicoPaymasterClient } from "../clients/pimlico"
-import type { PimlicoUserOperationStatus } from "../types/pimlico"
-import type { UserOperation, UserOperationWithBigIntAsHex } from "../types/userOperation"
-import { deepHexlify } from "./utils"
-
-export type SponsorUserOperationParameters = {
-    userOperation: PartialBy<
-        UserOperation,
-        "callGasLimit" | "preVerificationGas" | "verificationGasLimit" | "paymasterAndData"
-    >
-    entryPoint: Address
-}
-
-export type SponsorUserOperationReturnType = {
-    paymasterAndData: Hex
-    preVerificationGas: bigint
-    verificationGasLimit: bigint
-    callGasLimit: bigint
-}
-
-export type GetUserOperationGasPriceReturnType = {
-    slow: {
-        maxFeePerGas: bigint
-        maxPriorityFeePerGas: bigint
-    }
-    standard: {
-        maxFeePerGas: bigint
-        maxPriorityFeePerGas: bigint
-    }
-    fast: {
-        maxFeePerGas: bigint
-        maxPriorityFeePerGas: bigint
-    }
-}
-
-export type GetUserOperationStatusParameters = {
-    hash: Hash
-}
-
-export type GetUserOperationStatusReturnType = PimlicoUserOperationStatus
-
-/**
- * Returns the live gas prices that you can use to send a user operation.
- *
- * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationGasPrice
- *
- * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
- * @returns slow, standard & fast values for maxFeePerGas & maxPriorityFeePerGas
- *
- *
- * @example
- * import { createClient } from "viem"
- * import { getUserOperationGasPrice } from "permissionless/actions"
- *
- * const bundlerClient = createClient({
- *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
- * })
- *
- * await getUserOperationGasPrice(bundlerClient)
- *
- */
-export const getUserOperationGasPrice = async (
-    client: PimlicoBundlerClient
-): Promise<GetUserOperationGasPriceReturnType> => {
-    const gasPrices = await client.request({
-        method: "pimlico_getUserOperationGasPrice",
-        params: []
-    })
-
-    return {
-        slow: {
-            maxFeePerGas: BigInt(gasPrices.slow.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.slow.maxPriorityFeePerGas)
-        },
-        standard: {
-            maxFeePerGas: BigInt(gasPrices.standard.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.standard.maxPriorityFeePerGas)
-        },
-        fast: {
-            maxFeePerGas: BigInt(gasPrices.fast.maxFeePerGas),
-            maxPriorityFeePerGas: BigInt(gasPrices.fast.maxPriorityFeePerGas)
-        }
-    }
+import {
+    type GetUserOperationGasPriceReturnType,
+    getUserOperationGasPrice
+} from "./pimlico/getUserOperationGasPrice.js"
+import {
+    type GetUserOperationStatusParameters,
+    type GetUserOperationStatusReturnType,
+    getUserOperationStatus
+} from "./pimlico/getUserOperationStatus.js"
+import {
+    type SponsorUserOperationParameters,
+    type SponsorUserOperationReturnType,
+    sponsorUserOperation
+} from "./pimlico/sponsorUserOperation.js"
+
+import type { PimlicoBundlerActions, PimlicoPaymasterClientActions } from "../clients/decorators/pimlico.js"
+import { pimlicoBundlerActions, pimlicoPaymasterActions } from "../clients/decorators/pimlico.js"
+
+export type {
+    GetUserOperationGasPriceReturnType,
+    GetUserOperationStatusParameters,
+    GetUserOperationStatusReturnType,
+    SponsorUserOperationParameters,
+    SponsorUserOperationReturnType,
+    PimlicoBundlerActions,
+    PimlicoPaymasterClientActions
+}
+
+export {
+    getUserOperationGasPrice,
+    getUserOperationStatus,
+    sponsorUserOperation,
+    pimlicoBundlerActions,
+    pimlicoPaymasterActions
 }
-
-/**
- * Returns the status of the userOperation that is pending in the mempool.
- *
- * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationStatus
- *
- * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
- * @param hash {@link Hash} UserOpHash that you must have received from sendUserOperation.
- * @returns status & transaction hash if included {@link GetUserOperationStatusReturnType}
- *
- *
- * @example
- * import { createClient } from "viem"
- * import { getUserOperationStatus } from "permissionless/actions"
- *
- * const bundlerClient = createClient({
- *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
- * })
- *
- * await getUserOperationStatus(bundlerClient, { hash: userOpHash })
- *
- */
-export const getUserOperationStatus = async (
-    client: PimlicoBundlerClient,
-    { hash }: GetUserOperationStatusParameters
-): Promise<GetUserOperationStatusReturnType> => {
-    return client.request({
-        method: "pimlico_getUserOperationStatus",
-        params: [hash]
-    })
-}
-
-export type PimlicoBundlerActions = {
-    /**
-     * Returns the live gas prices that you can use to send a user operation.
-     *
-     * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationGasPrice
-     *
-     * @returns slow, standard & fast values for maxFeePerGas & maxPriorityFeePerGas {@link GetUserOperationGasPriceReturnType}
-     *
-     * @example
-     *
-     * import { createClient } from "viem"
-     * import { pimlicoBundlerActions } from "permissionless/actions"
-     *
-     * const bundlerClient = createClient({
-     *      chain: goerli,
-     *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
-     * }).extend(pimlicoBundlerActions)
-     *
-     * await bundlerClient.getUserOperationGasPrice()
-     */
-    getUserOperationGasPrice: () => Promise<GetUserOperationGasPriceReturnType>
-    /**
-     * Returns the status of the userOperation that is pending in the mempool.
-     *
-     * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-bundler-actions/getUserOperationStatus
-     *
-     * @param hash {@link Hash} UserOpHash that you must have received from sendUserOperation.
-     * @returns status & transaction hash if included {@link GetUserOperationStatusReturnType}
-     *
-     * @example
-     * import { createClient } from "viem"
-     * import { pimlicoBundlerActions } from "permissionless/actions"
-     *
-     * const bundlerClient = createClient({
-     *      chain: goerli,
-     *      transport: http("https://api.pimlico.io/v1/goerli/rpc?apikey=YOUR_API_KEY_HERE")
-     * }).extend(pimlicoBundlerActions)
-     *
-     * await bundlerClient.getUserOperationStatus({ hash: userOpHash })
-     */
-    getUserOperationStatus: (args: GetUserOperationStatusParameters) => Promise<GetUserOperationStatusReturnType>
-}
-
-export const pimlicoBundlerActions = (client: Client): PimlicoBundlerActions => ({
-    getUserOperationGasPrice: async () => getUserOperationGasPrice(client as PimlicoBundlerClient),
-    getUserOperationStatus: async (args: GetUserOperationStatusParameters) =>
-        getUserOperationStatus(client as PimlicoBundlerClient, args)
-})
-
-/**
- * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
- *
- * - Docs: https://docs.pimlico.io/permissionless/reference/pimlico-paymaster-actions/sponsorUserOperation
- *
- * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
- * @param args {@link sponsorUserOperationParameters} UserOperation you want to sponsor & entryPoint.
- * @returns paymasterAndData & updated gas parameters, see {@link SponsorUserOperationReturnType}
- *
- *
- * @example
- * import { createClient } from "viem"
- * import { sponsorUserOperation } from "permissionless/actions"
- *
- * const bundlerClient = createClient({
- *      chain: goerli,
- *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
- * })
- *
- * await sponsorUserOperation(bundlerClient, {
- *      userOperation: userOperationWithDummySignature,
- *      entryPoint: entryPoint
- * }})
- *
- */
-export const sponsorUserOperation = async (
-    client: PimlicoPaymasterClient,
-    args: SponsorUserOperationParameters
-): Promise<SponsorUserOperationReturnType> => {
-    const response = await client.request({
-        method: "pm_sponsorUserOperation",
-        params: [deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex, args.entryPoint]
-    })
-
-    return {
-        paymasterAndData: response.paymasterAndData,
-        preVerificationGas: BigInt(response.preVerificationGas),
-        verificationGasLimit: BigInt(response.verificationGasLimit),
-        callGasLimit: BigInt(response.callGasLimit)
-    }
-}
-
-export type PimlicoPaymasterClientActions = {
-    /**
-     * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
-     *
-     * https://docs.pimlico.io/permissionless/reference/pimlico-paymaster-actions/sponsorUserOperation
-     *
-     * @param args {@link SponsorUserOperationParameters} UserOperation you want to sponsor & entryPoint.
-     * @returns paymasterAndData & updated gas parameters, see {@link SponsorUserOperationReturnType}
-     *
-     * @example
-     * import { createClient } from "viem"
-     * import { sponsorUserOperation } from "permissionless/actions"
-     *
-     * const bundlerClient = createClient({
-     *      chain: goerli,
-     *      transport: http("https://api.pimlico.io/v2/goerli/rpc?apikey=YOUR_API_KEY_HERE")
-     * }).extend(pimlicoPaymasterActions)
-     *
-     * await bundlerClient.sponsorUserOperation(bundlerClient, {
-     *      userOperation: userOperationWithDummySignature,
-     *      entryPoint: entryPoint
-     * }})
-     *
-     */
-    sponsorUserOperation: (args: SponsorUserOperationParameters) => Promise<SponsorUserOperationReturnType>
-}
-
-export const pimlicoPaymasterActions = (client: Client): PimlicoPaymasterClientActions => ({
-    sponsorUserOperation: async (args: SponsorUserOperationParameters) =>
-        sponsorUserOperation(client as PimlicoPaymasterClient, args)
-})
-
-/**
- * TODO: Add support for pimlicoActions after we support all the actions of v1 in v2 of the Pimlico API.
- */
-// export const pimlicoActions = (client: Client) => {
-//     return {
-//         ...pimlicoBundlerActions(client),
-//         ...pimlicoPaymasterActions(client)
-//     }
-// }

package/actions/public/getAccountNonce.ts

@@ -0,0 +1,63 @@
+import type { Address, PublicClient } from "viem"
+
+export type GetAccountNonceParams = { sender: Address; entryPoint: Address; key?: bigint }
+
+/**
+ * Returns the nonce of the account with the entry point.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/public-actions/getAccountNonce
+ *
+ * @param publicClient {@link PublicClient} that you created using viem's createPublicClient.
+ * @param args {@link GetAccountNonceParams} address, entryPoint & key
+ * @returns bigint nonce
+ *
+ * @example
+ * import { createPublicClient } from "viem"
+ * import { getAccountNonce } from "permissionless/actions"
+ *
+ * const publicClient = createPublicClient({
+ *      chain: goerli,
+ *      transport: http("https://goerli.infura.io/v3/your-infura-key")
+ * })
+ *
+ * const nonce = await getAccountNonce(publicClient, {
+ *      address,
+ *      entryPoint,
+ *      key
+ * })
+ *
+ * // Return 0n
+ */
+export const getAccountNonce = async (
+    publicClient: PublicClient,
+    { sender, entryPoint, key = BigInt(0) }: GetAccountNonceParams
+): Promise<bigint> => {
+    return await publicClient.readContract({
+        address: entryPoint,
+        abi: [
+            {
+                inputs: [
+                    {
+                        name: "sender",
+                        type: "address"
+                    },
+                    {
+                        name: "key",
+                        type: "uint192"
+                    }
+                ],
+                name: "getNonce",
+                outputs: [
+                    {
+                        name: "nonce",
+                        type: "uint256"
+                    }
+                ],
+                stateMutability: "view",
+                type: "function"
+            }
+        ],
+        functionName: "getNonce",
+        args: [sender, key]
+    })
+}

package/actions/{public.ts → public/getSenderAddress.ts}

@@ -1,14 +1,13 @@
-import type {
-    Address,
-    ContractFunctionExecutionErrorType,
-    ContractFunctionRevertedErrorType,
-    Hex,
-    PublicClient
+import {
+    type Address,
+    BaseError,
+    type ContractFunctionExecutionErrorType,
+    type ContractFunctionRevertedErrorType,
+    type Hex,
+    type PublicClient
 } from "viem"
-import { BaseError } from "viem"
 
 export type GetSenderAddressParams = { initCode: Hex; entryPoint: Address }
-export type GetAccountNonceParams = { address: Address; entryPoint: Address; key?: bigint }
 
 export class InvalidEntryPointError extends BaseError {
     override name = "InvalidEntryPointError"
@@ -103,63 +102,3 @@ export const getSenderAddress = async (
 
     throw new InvalidEntryPointError({ entryPoint })
 }
-
-/**
- * Returns the nonce of the account with the entry point.
- *
- * - Docs: https://docs.pimlico.io/permissionless/reference/public-actions/getAccountNonce
- *
- * @param publicClient {@link PublicClient} that you created using viem's createPublicClient.
- * @param args {@link GetAccountNonceParams} address, entryPoint & key
- * @returns bigint nonce
- *
- * @example
- * import { createPublicClient } from "viem"
- * import { getAccountNonce } from "permissionless/actions"
- *
- * const publicClient = createPublicClient({
- *      chain: goerli,
- *      transport: http("https://goerli.infura.io/v3/your-infura-key")
- * })
- *
- * const nonce = await getAccountNonce(publicClient, {
- *      address,
- *      entryPoint,
- *      key
- * })
- *
- * // Return 0n
- */
-export const getAccountNonce = async (
-    publicClient: PublicClient,
-    { address, entryPoint, key = 0n }: GetAccountNonceParams
-): Promise<bigint> => {
-    return await publicClient.readContract({
-        address: entryPoint,
-        abi: [
-            {
-                inputs: [
-                    {
-                        name: "sender",
-                        type: "address"
-                    },
-                    {
-                        name: "key",
-                        type: "uint192"
-                    }
-                ],
-                name: "getNonce",
-                outputs: [
-                    {
-                        name: "nonce",
-                        type: "uint256"
-                    }
-                ],
-                stateMutability: "view",
-                type: "function"
-            }
-        ],
-        functionName: "getNonce",
-        args: [address, key]
-    })
-}

package/actions/stackup/accounts.ts

@@ -0,0 +1,40 @@
+import type { Address } from "viem"
+import type { StackupPaymasterClient } from "../../clients/stackup.js"
+
+export type AccountsParameters = {
+    entryPoint: Address
+}
+
+/**
+ * Returns all the Paymaster addresses associated with an EntryPoint that’s owned by this service.
+ *
+ * https://docs.stackup.sh/docs/paymaster-api-rpc-methods#pm_accounts
+ *
+ * @param args {@link AccountsParameters} entryPoint for which you want to get list of supported paymasters.
+ * @returns paymaster addresses
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { accounts } from "permissionless/actions/stackup"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http("https://api.stackup.sh/v1/paymaster/YOUR_API_KEY_HERE")
+ * })
+ *
+ * await accounts(bundlerClient, {
+ *      entryPoint: entryPoint
+ * }})
+ *
+ */
+export const accounts = async (
+    client: StackupPaymasterClient,
+    { entryPoint }: AccountsParameters
+): Promise<Address[]> => {
+    const response = await client.request({
+        method: "pm_accounts",
+        params: [entryPoint]
+    })
+
+    return response
+}

package/actions/stackup/sponsorUserOperation.ts

@@ -0,0 +1,64 @@
+import type { Address, Hex } from "viem"
+import type { PartialBy } from "viem/types/utils"
+import { type StackupPaymasterClient } from "../../clients/stackup.js"
+import type { StackupPaymasterContext } from "../../types/stackup.js"
+import type { UserOperation, UserOperationWithBigIntAsHex } from "../../types/userOperation.js"
+import { deepHexlify } from "../../utils/deepHexlify.js"
+
+export type SponsorUserOperationParameters = {
+    userOperation: PartialBy<
+        UserOperation,
+        "callGasLimit" | "preVerificationGas" | "verificationGasLimit" | "paymasterAndData"
+    >
+    entryPoint: Address
+    context: StackupPaymasterContext
+}
+
+export type SponsorUserOperationReturnType = {
+    paymasterAndData: Hex
+    preVerificationGas: bigint
+    verificationGasLimit: bigint
+    callGasLimit: bigint
+}
+
+/**
+ * Returns paymasterAndData & updated gas parameters required to sponsor a userOperation.
+ *
+ * - Docs: https://docs.pimlico.io/permissionless/reference/stackup-paymaster-actions/sponsorUserOperation
+ *
+ * @param client {@link PimlicoBundlerClient} that you created using viem's createClient whose transport url is pointing to the Pimlico's bundler.
+ * @param args {@link sponsorUserOperationParameters} UserOperation you want to sponsor & entryPoint.
+ * @returns paymasterAndData & updated gas parameters, see {@link SponsorUserOperationReturnType}
+ *
+ *
+ * @example
+ * import { createClient } from "viem"
+ * import { sponsorUserOperation } from "permissionless/actions/stackup"
+ *
+ * const bundlerClient = createClient({
+ *      chain: goerli,
+ *      transport: http("https://api.stackup.sh/v1/paymaster/YOUR_API_KEY_HERE")
+ * })
+ *
+ * await sponsorUserOperation(bundlerClient, {
+ *      userOperation: userOperationWithDummySignature,
+ *      entryPoint: entryPoint
+ * }})
+ *
+ */
+export const sponsorUserOperation = async (
+    client: StackupPaymasterClient,
+    args: SponsorUserOperationParameters
+): Promise<SponsorUserOperationReturnType> => {
+    const response = await client.request({
+        method: "pm_sponsorUserOperation",
+        params: [deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex, args.entryPoint, args.context]
+    })
+
+    return {
+        paymasterAndData: response.paymasterAndData,
+        preVerificationGas: BigInt(response.preVerificationGas),
+        verificationGasLimit: BigInt(response.verificationGasLimit),
+        callGasLimit: BigInt(response.callGasLimit)
+    }
+}

package/actions/stackup.ts

@@ -0,0 +1,17 @@
+import type { StackupPaymasterClientActions } from "../clients/decorators/stackup.js"
+import { stackupPaymasterActions } from "../clients/decorators/stackup.js"
+import { type AccountsParameters, accounts } from "./stackup/accounts.js"
+import {
+    type SponsorUserOperationParameters,
+    type SponsorUserOperationReturnType,
+    sponsorUserOperation
+} from "./stackup/sponsorUserOperation.js"
+
+export type {
+    SponsorUserOperationParameters,
+    SponsorUserOperationReturnType,
+    AccountsParameters,
+    StackupPaymasterClientActions
+}
+
+export { sponsorUserOperation, accounts, stackupPaymasterActions }

package/clients/bundler.ts

@@ -1,10 +1,15 @@
 import type { Account, Chain, Client, PublicClientConfig, Transport } from "viem"
 import { createClient } from "viem"
-import { bundlerActions } from "../actions"
-import type { BundlerActions } from "../actions/bundler"
-import type { BundlerRpcSchema } from "../types/bundler"
+import type { BundlerRpcSchema } from "../types/bundler.js"
+import { type BundlerActions, bundlerActions } from "./decorators/bundler.js"
 
-export type BundlerClient = Client<Transport, Chain | undefined, Account | undefined, BundlerRpcSchema, BundlerActions>
+export type BundlerClient<TChain extends Chain | undefined = Chain | undefined> = Client<
+    Transport,
+    TChain,
+    Account | undefined,
+    BundlerRpcSchema,
+    BundlerActions
+>
 /**
  * Creates a EIP-4337 compliant Bundler Client with a given [Transport](https://viem.sh/docs/clients/intro.html) configured for a [Chain](https://viem.sh/docs/clients/chains.html).
  *