permissionless 0.2.8 → 0.2.10

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

@@ -133,6 +133,18 @@ export const getSenderAddress = async (
                 err instanceof UnknownRpcError
         )
 
+        if (!revertError) {
+            const cause = (e as ContractFunctionExecutionErrorType).cause as any
+            const errorName = cause?.data?.errorName ?? ""
+            if (
+                errorName === "SenderAddressResult" &&
+                cause?.data?.args &&
+                cause?.data?.args[0]
+            ) {
+                return cause.data?.args[0] as Address
+            }
+        }
+
         if (revertError instanceof ContractFunctionRevertedError) {
             const errorName = revertError.data?.errorName ?? ""
             if (

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "permissionless",
-    "version": "0.2.8",
+    "version": "0.2.10",
     "author": "Pimlico",
     "homepage": "https://docs.pimlico.io/permissionless",
     "repository": "github:pimlicolabs/permissionless.js",