permissionless 0.2.7 → 0.2.9

package/accounts/thirdweb/utils/encodeCallData.ts

@@ -0,0 +1,81 @@
+import { encodeFunctionData } from "viem"
+
+export const encodeCallData = async (
+    calls: readonly {
+        to: `0x${string}`
+        value?: bigint | undefined
+        data?: `0x${string}` | undefined
+    }[]
+) => {
+    if (calls.length > 1) {
+        return encodeFunctionData({
+            abi: [
+                {
+                    inputs: [
+                        {
+                            internalType: "address[]",
+                            name: "dest",
+                            type: "address[]"
+                        },
+                        {
+                            internalType: "uint256[]",
+                            name: "value",
+                            type: "uint256[]"
+                        },
+                        {
+                            internalType: "bytes[]",
+                            name: "func",
+                            type: "bytes[]"
+                        }
+                    ],
+                    name: "executeBatch",
+                    outputs: [],
+                    stateMutability: "nonpayable",
+                    type: "function"
+                }
+            ],
+            functionName: "executeBatch",
+            args: [
+                calls.map((a) => a.to),
+                calls.map((a) => a.value ?? 0n),
+                calls.map((a) => a.data ?? "0x")
+            ]
+        })
+    }
+
+    const call = calls.length === 0 ? undefined : calls[0]
+
+    if (!call) {
+        throw new Error("No calls to encode")
+    }
+
+    return encodeFunctionData({
+        abi: [
+            {
+                inputs: [
+                    {
+                        internalType: "address",
+                        name: "dest",
+                        type: "address"
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "value",
+                        type: "uint256"
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "func",
+                        type: "bytes"
+                    }
+                ],
+                name: "execute",
+                outputs: [],
+                stateMutability: "nonpayable",
+                type: "function"
+            }
+        ],
+        functionName: "execute",
+        args: [call.to, call.value ?? 0n, call.data ?? "0x"]
+    })
+}

package/accounts/thirdweb/utils/getAccountAddress.ts

@@ -0,0 +1,48 @@
+import type { Address, Client, Hex } from "viem"
+import { readContract } from "viem/actions"
+import { getAction } from "viem/utils"
+
+export type GetAccountAddressParams = {
+    adminAddress: Address
+    factoryAddress: Address
+    salt: Hex
+}
+
+export const getAccountAddress = async (
+    client: Client,
+    args: GetAccountAddressParams
+): Promise<Address> => {
+    const { adminAddress, factoryAddress, salt } = args
+
+    return getAction(
+        client,
+        readContract,
+        "readContract"
+    )({
+        address: factoryAddress,
+        abi: [
+            {
+                inputs: [
+                    {
+                        name: "_adminSigner",
+                        type: "address"
+                    },
+                    {
+                        name: "_data",
+                        type: "bytes"
+                    }
+                ],
+                name: "getAddress",
+                outputs: [
+                    {
+                        type: "address"
+                    }
+                ],
+                stateMutability: "view",
+                type: "function"
+            }
+        ],
+        functionName: "getAddress",
+        args: [adminAddress, salt]
+    })
+}

package/accounts/thirdweb/utils/getFactoryData.ts

@@ -0,0 +1,40 @@
+import type { Address, Hex } from "viem"
+import { encodeFunctionData } from "viem"
+
+export const getFactoryData = async ({
+    admin,
+    salt
+}: {
+    admin: Address
+    salt: Hex
+}) => {
+    return encodeFunctionData({
+        abi: [
+            {
+                inputs: [
+                    {
+                        internalType: "address",
+                        name: "_admin",
+                        type: "address"
+                    },
+                    {
+                        internalType: "bytes",
+                        name: "_salt",
+                        type: "bytes"
+                    }
+                ],
+                name: "createAccount",
+                outputs: [
+                    {
+                        internalType: "address",
+                        type: "address"
+                    }
+                ],
+                stateMutability: "nonpayable",
+                type: "function"
+            }
+        ],
+        functionName: "createAccount",
+        args: [admin, salt]
+    })
+}

package/accounts/thirdweb/utils/signMessage.ts

@@ -0,0 +1,34 @@
+import {
+    type Address,
+    type LocalAccount,
+    type SignMessageReturnType,
+    type SignableMessage,
+    hashMessage
+} from "viem"
+import { signMessage as _signMessage } from "viem/actions"
+
+export async function signMessage({
+    message,
+    admin,
+    accountAddress,
+    chainId
+}: {
+    chainId: number
+    message: SignableMessage
+    admin: LocalAccount
+    accountAddress: Address
+}): Promise<SignMessageReturnType> {
+    const hashedMessage = hashMessage(message)
+
+    return admin.signTypedData({
+        domain: {
+            name: "Account",
+            version: "1",
+            chainId,
+            verifyingContract: accountAddress
+        },
+        primaryType: "AccountMessage",
+        types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+        message: { message: hashedMessage }
+    })
+}

package/accounts/thirdweb/utils/signTypedData.ts

@@ -0,0 +1,67 @@
+import {
+    type Address,
+    type LocalAccount,
+    type SignTypedDataReturnType,
+    type TypedDataDefinition,
+    type TypedDataDomain,
+    encodeAbiParameters,
+    getTypesForEIP712Domain,
+    hashTypedData,
+    validateTypedData
+} from "viem"
+
+export async function signTypedData(
+    parameters: TypedDataDefinition & {
+        accountAddress: Address
+        chainId: number
+        admin: LocalAccount
+    }
+): Promise<SignTypedDataReturnType> {
+    const { admin, accountAddress, chainId, ...typedData } = parameters
+    const isSelfVerifyingContract =
+        (
+            typedData.domain as TypedDataDomain
+        )?.verifyingContract?.toLowerCase() === accountAddress
+
+    // If this is a self-verifying contract, we can use the admin's signature
+    if (isSelfVerifyingContract) {
+        return admin.signTypedData({
+            ...typedData
+        })
+    }
+
+    const { message, primaryType, types: _types, domain } = typedData
+    const types = {
+        EIP712Domain: getTypesForEIP712Domain({
+            domain: domain
+        }),
+        ..._types
+    }
+
+    // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
+    // as we can't statically check this with TypeScript.
+    validateTypedData({
+        domain,
+        message,
+        primaryType,
+        types
+    })
+
+    const typedHash = hashTypedData({ message, primaryType, types, domain })
+    const wrappedMessageHash = encodeAbiParameters(
+        [{ type: "bytes32" }],
+        [typedHash]
+    )
+
+    return admin.signTypedData({
+        domain: {
+            name: "Account",
+            version: "1",
+            chainId,
+            verifyingContract: accountAddress
+        },
+        primaryType: "AccountMessage",
+        types: { AccountMessage: [{ name: "message", type: "bytes" }] },
+        message: { message: wrappedMessageHash }
+    })
+}

package/actions/public/getSenderAddress.ts

@@ -8,6 +8,7 @@ import {
     InvalidInputRpcError,
     type OneOf,
     type Prettify,
+    RawContractError,
     RpcRequestError,
     UnknownRpcError,
     concat,
@@ -179,20 +180,22 @@ export const getSenderAddress = async (
         }
 
         if (revertError instanceof InvalidInputRpcError) {
-            const hexStringRegex = /0x[a-fA-F0-9]+/
-            // biome-ignore lint/suspicious/noExplicitAny:
-            const match = (revertError as unknown as any).cause.data.match(
-                hexStringRegex
-            )
+            const { data: data_ } = (
+                e instanceof RawContractError
+                    ? e
+                    : e instanceof BaseError
+                      ? e.walk((err) => "data" in (err as Error)) || e.walk()
+                      : {}
+            ) as RawContractError
 
-            if (!match) {
+            const data = typeof data_ === "string" ? data_ : data_?.data
+
+            if (data === undefined) {
                 throw new Error(
                     "Failed to parse revert bytes from RPC response"
                 )
             }
 
-            const data: Hex = match[0]
-
             const error = decodeErrorResult({
                 abi: [
                     {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "permissionless",
-    "version": "0.2.7",
+    "version": "0.2.9",
     "author": "Pimlico",
     "homepage": "https://docs.pimlico.io/permissionless",
     "repository": "github:pimlicolabs/permissionless.js",
@@ -11,13 +11,7 @@
     "type": "module",
     "sideEffects": false,
     "description": "A utility library for working with ERC-4337",
-    "keywords": [
-        "ethereum",
-        "erc-4337",
-        "eip-4337",
-        "paymaster",
-        "bundler"
-    ],
+    "keywords": ["ethereum", "erc-4337", "eip-4337", "paymaster", "bundler"],
     "license": "MIT",
     "exports": {
         ".": {