permissionless 0.0.11 → 0.0.13

package/actions/smartAccount/sendTransactions.ts

@@ -0,0 +1,141 @@
+import type {
+    Address,
+    Chain,
+    Client,
+    Hex,
+    SendTransactionParameters,
+    SendTransactionReturnType,
+    Transport
+} from "viem"
+import { type SmartAccount } from "../../accounts/types.js"
+import type { GetAccountParameter } from "../../types/index.js"
+import { getAction } from "../../utils/getAction.js"
+import {
+    AccountOrClientNotFoundError,
+    parseAccount
+} from "../../utils/index.js"
+import { waitForUserOperationReceipt } from "../bundler/waitForUserOperationReceipt.js"
+import { type SponsorUserOperationMiddleware } from "./prepareUserOperationRequest.js"
+import { sendUserOperation } from "./sendUserOperation.js"
+
+export type SendTransactionsWithPaymasterParameters<
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+> = {
+    transactions: { to: Address; value: bigint; data: Hex }[]
+} & GetAccountParameter<TAccount> &
+    SponsorUserOperationMiddleware & {
+        maxFeePerGas?: bigint
+        maxPriorityFeePerGas?: bigint
+        nonce?: bigint
+    }
+
+/**
+ * Creates, signs, and sends a new transactions to the network.
+ * This function also allows you to sponsor this transaction if sender is a smartAccount
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendTransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash. {@link SendTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendTransaction(client, [{
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * }, {
+ *   to: '0x61897970c51812dc3a010c7d01b50e0d17dc1234',
+ *   value: 10000000000000000n,
+ * }])
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const hash = await sendTransactions(client, [{
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * }, {
+ *   to: '0x61897970c51812dc3a010c7d01b50e0d17dc1234',
+ *   value: 10000000000000000n,
+ * }])
+ */
+export async function sendTransactions<
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    args: SendTransactionsWithPaymasterParameters<TAccount>
+): Promise<SendTransactionReturnType> {
+    const {
+        account: account_ = client.account,
+        transactions,
+        sponsorUserOperation,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce
+    } = args
+
+    if (!account_) {
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/docs/actions/wallet/sendTransaction"
+        })
+    }
+
+    const account = parseAccount(account_) as SmartAccount
+
+    if (account.type !== "local") {
+        throw new Error("RPC account type not supported")
+    }
+
+    const callData = await account.encodeCallData(
+        transactions.map(({ to, value, data }) => {
+            if (!to) throw new Error("Missing to address")
+            return {
+                to,
+                value: value || 0n,
+                data: data || "0x"
+            }
+        })
+    )
+
+    const userOpHash = await getAction(
+        client,
+        sendUserOperation
+    )({
+        userOperation: {
+            sender: account.address,
+            paymasterAndData: "0x",
+            maxFeePerGas: maxFeePerGas || 0n,
+            maxPriorityFeePerGas: maxPriorityFeePerGas || 0n,
+            callData: callData,
+            nonce: nonce
+        },
+        account: account,
+        sponsorUserOperation
+    })
+
+    const userOperationReceipt = await getAction(
+        client,
+        waitForUserOperationReceipt
+    )({
+        hash: userOpHash
+    })
+
+    return userOperationReceipt?.receipt.transactionHash
+}

package/actions/smartAccount/sendUserOperation.ts

@@ -0,0 +1,70 @@
+import type { Chain, Client, Hex, Transport } from "viem"
+import type { SmartAccount } from "../../accounts/types.js"
+import type {
+    GetAccountParameter,
+    PartialBy,
+    UserOperation
+} from "../../types/index.js"
+import { getAction } from "../../utils/getAction.js"
+import {
+    AccountOrClientNotFoundError,
+    parseAccount
+} from "../../utils/index.js"
+import { sendUserOperation as sendUserOperationBundler } from "../bundler/sendUserOperation.js"
+import {
+    type SponsorUserOperationMiddleware,
+    prepareUserOperationRequest
+} from "./prepareUserOperationRequest.js"
+
+export type SendUserOperationParameters<
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+> = {
+    userOperation: PartialBy<
+        UserOperation,
+        | "nonce"
+        | "sender"
+        | "initCode"
+        | "signature"
+        | "callGasLimit"
+        | "maxFeePerGas"
+        | "maxPriorityFeePerGas"
+        | "preVerificationGas"
+        | "verificationGasLimit"
+        | "paymasterAndData"
+    >
+} & GetAccountParameter<TAccount> &
+    SponsorUserOperationMiddleware
+
+export type SendUserOperationReturnType = Hex
+
+export async function sendUserOperation<
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+>(
+    client: Client<TTransport, TChain, TAccount>,
+    args: SendUserOperationParameters<TAccount>
+): Promise<SendUserOperationReturnType> {
+    const { account: account_ = client.account } = args
+    if (!account_) throw new AccountOrClientNotFoundError()
+
+    const account = parseAccount(account_) as SmartAccount
+
+    const userOperation = await getAction(
+        client,
+        prepareUserOperationRequest
+    )(args)
+
+    userOperation.signature = await account.signUserOperation(userOperation)
+
+    const userOpHash = await getAction(
+        client,
+        sendUserOperationBundler,
+        "sendUserOperation"
+    )({
+        userOperation: userOperation,
+        entryPoint: account.entryPoint
+    })
+
+    return userOpHash
+}

package/actions/smartAccount/signMessage.ts

@@ -0,0 +1,79 @@
+import type {
+    Chain,
+    Client,
+    SignMessageParameters,
+    SignMessageReturnType,
+    Transport
+} from "viem"
+import { type SmartAccount } from "../../accounts/types.js"
+import {
+    AccountOrClientNotFoundError,
+    parseAccount
+} from "../../utils/index.js"
+
+/**
+ * Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signMessage.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`personal_sign`](https://docs.metamask.io/guide/signing-data.html#personal-sign)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * With the calculated signature, you can:
+ * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage.html) to verify the signature,
+ * - use [`recoverMessageAddress`](https://viem.sh/docs/utilities/recoverMessageAddress.html) to recover the signing address from a signature.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignMessageParameters}
+ * @returns The signed message. {@link SignMessageReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signMessage(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   message: 'hello world',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, custom } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signMessage(client, {
+ *   message: 'hello world',
+ * })
+ */
+export async function signMessage<
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    {
+        account: account_ = client.account,
+        message
+    }: SignMessageParameters<TAccount>
+): Promise<SignMessageReturnType> {
+    if (!account_)
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/docs/actions/wallet/signMessage"
+        })
+
+    const account = parseAccount(account_)
+    if (account.type === "local") return account.signMessage({ message })
+
+    throw new Error("Sign message is not supported by this account")
+}

package/actions/smartAccount/signTypedData.ts

@@ -0,0 +1,161 @@
+import {
+    type Chain,
+    type Client,
+    type SignTypedDataParameters,
+    type SignTypedDataReturnType,
+    type Transport,
+    type TypedData,
+    type TypedDataDefinition,
+    getTypesForEIP712Domain,
+    validateTypedData
+} from "viem"
+import { type SmartAccount } from "../../accounts/types.js"
+import {
+    AccountOrClientNotFoundError,
+    parseAccount
+} from "../../utils/index.js"
+
+/**
+ * Signs typed data and calculates an Ethereum-specific signature in [https://eips.ethereum.org/EIPS/eip-712](https://eips.ethereum.org/EIPS/eip-712): `sign(keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message)))`
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signTypedData.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_signTypedData_v4`](https://docs.metamask.io/guide/signing-data.html#signtypeddata-v4)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignTypedDataParameters}
+ * @returns The signed data. {@link SignTypedDataReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTypedData(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const signature = await signTypedData(client, {
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ * })
+ */
+export async function signTypedData<
+    const TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends string,
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    {
+        account: account_ = client.account,
+        domain,
+        message,
+        primaryType,
+        types: types_
+    }: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
+): Promise<SignTypedDataReturnType> {
+    if (!account_) {
+        throw new AccountOrClientNotFoundError({
+            docsPath: "/docs/actions/wallet/signMessage"
+        })
+    }
+
+    const account = parseAccount(account_)
+
+    const types = {
+        EIP712Domain: getTypesForEIP712Domain({ domain }),
+        ...(types_ as TTypedData)
+    }
+
+    validateTypedData({
+        domain,
+        message,
+        primaryType,
+        types
+    } as TypedDataDefinition)
+
+    if (account.type === "local") {
+        return account.signTypedData({
+            domain,
+            primaryType,
+            types,
+            message
+        } as TypedDataDefinition)
+    }
+
+    throw new Error("Sign type message is not supported by this account")
+}

package/actions/smartAccount/writeContract.ts

@@ -0,0 +1,126 @@
+import {
+    type Abi,
+    type Chain,
+    type Client,
+    type EncodeFunctionDataParameters,
+    type Transport,
+    type WriteContractParameters,
+    type WriteContractReturnType,
+    encodeFunctionData
+} from "viem"
+import { type SmartAccount } from "../../accounts/types.js"
+import { getAction } from "../../utils/getAction.js"
+import { type SponsorUserOperationMiddleware } from "./prepareUserOperationRequest.js"
+import {
+    type SendTransactionWithPaymasterParameters,
+    sendTransaction
+} from "./sendTransaction.js"
+
+/**
+ * Executes a write function on a contract.
+ * This function also allows you to sponsor this transaction if sender is a smartAccount
+ *
+ * - Docs: https://viem.sh/docs/contract/writeContract.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
+ *
+ * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms.html) is needed to be broadcast in order to change the state.
+ *
+ * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet.html) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+ *
+ * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract.html#usage) before you execute it.__
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WriteContractParameters}
+ * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms.html#hash). {@link WriteContractReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { writeContract } from 'viem/contract'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await writeContract(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+ *   functionName: 'mint',
+ *   args: [69420],
+ * })
+ *
+ * @example
+ * // With Validation
+ * import { createWalletClient, http, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { simulateContract, writeContract } from 'viem/contract'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const { request } = await simulateContract(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+ *   functionName: 'mint',
+ *   args: [69420],
+ * }
+ * const hash = await writeContract(client, request)
+ */
+export type WriteContractWithPaymasterParameters<
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined,
+    TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[],
+    TFunctionName extends string = string,
+    TChainOverride extends Chain | undefined = undefined
+> = WriteContractParameters<
+    TAbi,
+    TFunctionName,
+    TChain,
+    TAccount,
+    TChainOverride
+> &
+    SponsorUserOperationMiddleware
+
+export async function writeContract<
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined,
+    const TAbi extends Abi | readonly unknown[],
+    TFunctionName extends string,
+    TChainOverride extends Chain | undefined = undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    {
+        abi,
+        address,
+        args,
+        dataSuffix,
+        functionName,
+        ...request
+    }: WriteContractWithPaymasterParameters<
+        TChain,
+        TAccount,
+        TAbi,
+        TFunctionName,
+        TChainOverride
+    >
+): Promise<WriteContractReturnType> {
+    const data = encodeFunctionData({
+        abi,
+        args,
+        functionName
+    } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
+    const hash = await getAction(
+        client,
+        sendTransaction<TChain, TAccount, TChainOverride>
+    )({
+        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
+        to: address,
+        ...request
+    } as unknown as SendTransactionWithPaymasterParameters<
+        TChain,
+        TAccount,
+        TChainOverride
+    >)
+    return hash
+}

package/actions/smartAccount.ts

@@ -0,0 +1,49 @@
+import {
+    type DeployContractParametersWithPaymaster,
+    deployContract
+} from "./smartAccount/deployContract.js"
+
+import {
+    type PrepareUserOperationRequestParameters,
+    type PrepareUserOperationRequestReturnType,
+    type SponsorUserOperationMiddleware,
+    prepareUserOperationRequest
+} from "./smartAccount/prepareUserOperationRequest.js"
+
+import {
+    type SendTransactionWithPaymasterParameters,
+    sendTransaction
+} from "./smartAccount/sendTransaction.js"
+
+import {
+    type SendUserOperationParameters,
+    type SendUserOperationReturnType,
+    sendUserOperation
+} from "./smartAccount/sendUserOperation.js"
+
+import { signMessage } from "./smartAccount/signMessage.js"
+
+import { signTypedData } from "./smartAccount/signTypedData.js"
+
+import {
+    type SendTransactionsWithPaymasterParameters,
+    sendTransactions
+} from "./smartAccount/sendTransactions.js"
+
+export {
+    deployContract,
+    type DeployContractParametersWithPaymaster,
+    prepareUserOperationRequest,
+    type PrepareUserOperationRequestParameters,
+    type PrepareUserOperationRequestReturnType,
+    sendTransaction,
+    sendUserOperation,
+    type SendUserOperationParameters,
+    type SendUserOperationReturnType,
+    signMessage,
+    signTypedData,
+    type SendTransactionWithPaymasterParameters,
+    type SponsorUserOperationMiddleware,
+    sendTransactions,
+    type SendTransactionsWithPaymasterParameters
+}

package/actions/stackup/accounts.ts

@@ -19,7 +19,7 @@ export type AccountsParameters = {
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
- *      transport: http("https://api.stackup.sh/v1/paymaster/YOUR_API_KEY_HERE")
+ *      transport: http("https://api.stackup.sh/v2/paymaster/YOUR_API_KEY_HERE")
  * })
  *
  * await accounts(bundlerClient, {

package/actions/stackup/sponsorUserOperation.ts

@@ -2,13 +2,19 @@ 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 type {
+    UserOperation,
+    UserOperationWithBigIntAsHex
+} from "../../types/userOperation.js"
 import { deepHexlify } from "../../utils/deepHexlify.js"
 
 export type SponsorUserOperationParameters = {
     userOperation: PartialBy<
         UserOperation,
-        "callGasLimit" | "preVerificationGas" | "verificationGasLimit" | "paymasterAndData"
+        | "callGasLimit"
+        | "preVerificationGas"
+        | "verificationGasLimit"
+        | "paymasterAndData"
     >
     entryPoint: Address
     context: StackupPaymasterContext
@@ -37,7 +43,7 @@ export type SponsorUserOperationReturnType = {
  *
  * const bundlerClient = createClient({
  *      chain: goerli,
- *      transport: http("https://api.stackup.sh/v1/paymaster/YOUR_API_KEY_HERE")
+ *      transport: http("https://api.stackup.sh/v2/paymaster/YOUR_API_KEY_HERE")
  * })
  *
  * await sponsorUserOperation(bundlerClient, {
@@ -52,7 +58,11 @@ export const sponsorUserOperation = async (
 ): Promise<SponsorUserOperationReturnType> => {
     const response = await client.request({
         method: "pm_sponsorUserOperation",
-        params: [deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex, args.entryPoint, args.context]
+        params: [
+            deepHexlify(args.userOperation) as UserOperationWithBigIntAsHex,
+            args.entryPoint,
+            args.context
+        ]
     })
 
     return {