permissionless 0.2.25 → 0.2.27

package/accounts/kernel/utils/decodeCallData.ts

@@ -0,0 +1,43 @@
+import { type Hex, decodeFunctionData } from "viem"
+import { decode7579Calls } from "../../../utils/decode7579Calls.js"
+import { KernelExecuteAbi } from "../abi/KernelAccountAbi.js"
+import type { KernelVersion } from "../toKernelSmartAccount.js"
+import { isKernelV2 } from "./isKernelV2.js"
+
+export const decodeCallData = ({
+    kernelVersion,
+    callData
+}: {
+    callData: Hex
+    kernelVersion: KernelVersion<"0.6" | "0.7">
+}) => {
+    if (isKernelV2(kernelVersion)) {
+        const decoded = decodeFunctionData({
+            abi: KernelExecuteAbi,
+            data: callData
+        })
+
+        if (decoded.functionName === "executeBatch") {
+            return decoded.args[0].map((tx) => ({
+                to: tx.to,
+                value: tx.value,
+                data: tx.data
+            }))
+        }
+
+        if (decoded.functionName === "execute") {
+            const [to, value, data] = decoded.args
+            return [
+                {
+                    to,
+                    value,
+                    data
+                }
+            ]
+        }
+
+        throw new Error("Invalid function name")
+    }
+
+    return decode7579Calls(callData).callData
+}

package/accounts/light/toLightSmartAccount.ts

@@ -10,6 +10,7 @@ import {
     type Transport,
     type WalletClient,
     concat,
+    decodeFunctionData,
     encodeFunctionData,
     hashMessage,
     hashTypedData
@@ -310,6 +311,95 @@ export async function toLightSmartAccount<
                 args: [call.to, call.value ?? 0n, call.data ?? "0x"]
             })
         },
+        async decodeCalls(callData) {
+            try {
+                const decoded = decodeFunctionData({
+                    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"
+                        }
+                    ],
+                    data: callData
+                })
+
+                if (decoded.functionName === "executeBatch") {
+                    const calls: {
+                        to: Address
+                        value: bigint
+                        data: Hex
+                    }[] = []
+
+                    for (let i = 0; i < decoded.args[0].length; i++) {
+                        calls.push({
+                            to: decoded.args[0][i],
+                            value: decoded.args[1][i],
+                            data: decoded.args[2][i]
+                        })
+                    }
+
+                    return calls
+                }
+
+                throw new Error("Invalid function name")
+            } catch (_) {
+                const decoded = decodeFunctionData({
+                    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"
+                        }
+                    ],
+                    data: callData
+                })
+
+                return [
+                    {
+                        to: decoded.args[0],
+                        value: decoded.args[1],
+                        data: decoded.args[2]
+                    }
+                ]
+            }
+        },
         async getNonce(args) {
             return getAccountNonce(client, {
                 address: await this.getAddress(),

package/accounts/nexus/toNexusSmartAccount.ts

@@ -38,6 +38,7 @@ import {
 import { getChainId, readContract } from "viem/actions"
 import { getAction } from "viem/utils"
 import { getAccountNonce } from "../../actions/public/getAccountNonce.js"
+import { decode7579Calls } from "../../utils/decode7579Calls.js"
 import { encode7579Calls } from "../../utils/encode7579Calls.js"
 import { type EthereumProvider, toOwner } from "../../utils/toOwner.js"
 
@@ -235,6 +236,9 @@ export async function toNexusSmartAccount(
                 callData: calls
             })
         },
+        async decodeCalls(callData) {
+            return decode7579Calls(callData).callData
+        },
         async getStubSignature() {
             const dynamicPart = validatorAddress.substring(2).padEnd(40, "0")
             return `0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000${dynamicPart}000000000000000000000000000000000000000000000000000000000000004181d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b00000000000000000000000000000000000000000000000000000000000000` as Hex

package/accounts/safe/toSafeSmartAccount.ts

@@ -13,15 +13,19 @@ import {
     type TypedDataDefinition,
     type WalletClient,
     concat,
+    decodeFunctionData,
     encodeAbiParameters,
     encodeFunctionData,
     encodePacked,
+    getAddress,
     getContractAddress,
     hashMessage,
     hashTypedData,
     hexToBigInt,
     keccak256,
     pad,
+    size,
+    slice,
     toBytes,
     toHex,
     zeroAddress
@@ -38,6 +42,7 @@ import {
 import { getChainId, readContract } from "viem/actions"
 import { getAction } from "viem/utils"
 import { getAccountNonce } from "../../actions/public/getAccountNonce.js"
+import { decode7579Calls } from "../../utils/decode7579Calls.js"
 import { encode7579Calls } from "../../utils/encode7579Calls.js"
 import { isSmartAccountDeployed } from "../../utils/isSmartAccountDeployed.js"
 import { type EthereumProvider, toOwner } from "../../utils/toOwner.js"
@@ -490,6 +495,11 @@ const encodeInternalTransaction = (tx: {
     operation: 0 | 1
 }): string => {
     const encoded = encodePacked(
+        // uint8 = 1 byte for operation
+        // address = 20 bytes for to address
+        // uint256 = 32 bytes for value
+        // uint256 = 32 bytes for data length
+        // bytes = dynamic length for data
         ["uint8", "address", "uint256", "uint256", "bytes"],
         [
             tx.operation,
@@ -1401,6 +1411,81 @@ export async function toSafeSmartAccount<
                 args: [to, value, data, operationType]
             })
         },
+        async decodeCalls(callData) {
+            try {
+                const decoded = decodeFunctionData({
+                    abi: setupSafeAbi,
+                    data: callData
+                })
+
+                return decode7579Calls(decoded.args[0].callData).callData
+            } catch (_) {}
+
+            try {
+                return decode7579Calls(callData).callData
+            } catch (_) {}
+
+            const decoded = decodeFunctionData({
+                abi: executeUserOpWithErrorStringAbi,
+                data: callData
+            })
+
+            const to = decoded.args[0]
+            const value = decoded.args[1]
+            const data = decoded.args[2]
+
+            if (to === multiSendCallOnlyAddress) {
+                const decodedMultiSend = decodeFunctionData({
+                    abi: multiSendAbi,
+                    data: data
+                })
+
+                const dataToDecode = decodedMultiSend.args[0]
+                const transactions: {
+                    to: Address
+                    value: bigint
+                    data: Hex
+                }[] = []
+
+                let position = 0
+                const dataLength = size(dataToDecode)
+
+                while (position < dataLength) {
+                    // skip the operation type
+                    position += 1
+
+                    const to = getAddress(
+                        slice(dataToDecode, position, position + 20)
+                    )
+                    position += 20
+
+                    const value = BigInt(
+                        slice(dataToDecode, position, position + 32)
+                    )
+                    position += 32
+
+                    const dataLength = Number(
+                        BigInt(slice(dataToDecode, position, position + 32)) *
+                            BigInt(2)
+                    )
+
+                    position += 32
+
+                    const data = slice(
+                        dataToDecode,
+                        position,
+                        position + dataLength
+                    )
+                    position += dataLength
+
+                    transactions.push({ to, value, data })
+                }
+
+                return transactions
+            }
+
+            return [{ to, value, data }]
+        },
         async getNonce(args) {
             return getAccountNonce(client, {
                 address: await this.getAddress(),

package/accounts/simple/toSimpleSmartAccount.ts

@@ -9,6 +9,7 @@ import {
     type OneOf,
     type Transport,
     type WalletClient,
+    decodeFunctionData,
     encodeFunctionData
 } from "viem"
 import {
@@ -291,6 +292,132 @@ export async function toSimpleSmartAccount<
                 args: [call.to, call.value ?? 0n, call.data ?? "0x"]
             })
         },
+        decodeCalls: async (callData) => {
+            try {
+                const decodedV6 = decodeFunctionData({
+                    abi: [
+                        {
+                            inputs: [
+                                {
+                                    internalType: "address[]",
+                                    name: "dest",
+                                    type: "address[]"
+                                },
+                                {
+                                    internalType: "bytes[]",
+                                    name: "func",
+                                    type: "bytes[]"
+                                }
+                            ],
+                            name: "executeBatch",
+                            outputs: [],
+                            stateMutability: "nonpayable",
+                            type: "function"
+                        }
+                    ],
+                    data: callData
+                })
+
+                const calls: {
+                    to: Address
+                    data: Hex
+                    value?: bigint
+                }[] = []
+
+                for (let i = 0; i < decodedV6.args.length; i++) {
+                    calls.push({
+                        to: decodedV6.args[0][i],
+                        data: decodedV6.args[1][i],
+                        value: 0n
+                    })
+                }
+
+                return calls
+            } catch (_) {
+                try {
+                    const decodedV7 = decodeFunctionData({
+                        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"
+                            }
+                        ],
+                        data: callData
+                    })
+
+                    const calls: {
+                        to: Address
+                        data: Hex
+                        value?: bigint
+                    }[] = []
+
+                    for (let i = 0; i < decodedV7.args[0].length; i++) {
+                        calls.push({
+                            to: decodedV7.args[0][i],
+                            value: decodedV7.args[1][i],
+                            data: decodedV7.args[2][i]
+                        })
+                    }
+
+                    return calls
+                } catch (_) {
+                    const decodedSingle = decodeFunctionData({
+                        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"
+                            }
+                        ],
+                        data: callData
+                    })
+                    return [
+                        {
+                            to: decodedSingle.args[0],
+                            value: decodedSingle.args[1],
+                            data: decodedSingle.args[2]
+                        }
+                    ]
+                }
+            }
+        },
         async getNonce(args) {
             return getAccountNonce(client, {
                 address: await this.getAddress(),

package/accounts/thirdweb/toThirdwebSmartAccount.ts

@@ -25,6 +25,7 @@ import {
 } from "viem/account-abstraction"
 import { getAction, toHex } from "viem/utils"
 import { type EthereumProvider, toOwner } from "../../utils/toOwner.js"
+import { decodeCallData } from "./utils/decodeCallData.js"
 import { encodeCallData } from "./utils/encodeCallData.js"
 import { getAccountAddress } from "./utils/getAccountAddress.js"
 import { getFactoryData } from "./utils/getFactoryData.js"
@@ -158,6 +159,9 @@ export async function toThirdwebSmartAccount<
         async encodeCalls(calls) {
             return encodeCallData(calls)
         },
+        async decodeCalls(callData) {
+            return decodeCallData(callData)
+        },
         async getNonce(args) {
             return getAccountNonce(client, {
                 address: await this.getAddress(),

package/accounts/thirdweb/utils/decodeCallData.ts

@@ -0,0 +1,87 @@
+import { type Address, type Hex, decodeFunctionData } from "viem"
+
+export const decodeCallData = async (callData: `0x${string}`) => {
+    try {
+        const decodedBatch = decodeFunctionData({
+            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"
+                }
+            ],
+            data: callData
+        })
+
+        const calls: {
+            to: Address
+            data: Hex
+            value?: bigint
+        }[] = []
+
+        for (let i = 0; i < decodedBatch.args[0].length; i++) {
+            calls.push({
+                to: decodedBatch.args[0][i],
+                value: decodedBatch.args[1][i],
+                data: decodedBatch.args[2][i]
+            })
+        }
+
+        return calls
+    } catch (_) {}
+
+    const decodedSingle = decodeFunctionData({
+        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"
+            }
+        ],
+        data: callData
+    })
+
+    return [
+        {
+            to: decodedSingle.args[0],
+            value: decodedSingle.args[1],
+            data: decodedSingle.args[2]
+        }
+    ]
+}

package/accounts/trust/toTrustSmartAccount.ts

@@ -27,6 +27,7 @@ import {
 import { getAction } from "viem/utils"
 import { getSenderAddress } from "../../actions/public/getSenderAddress.js"
 import { type EthereumProvider, toOwner } from "../../utils/toOwner.js"
+import { decodeCallData } from "./utils/decodeCallData.js"
 import { encodeCallData } from "./utils/encodeCallData.js"
 import { getFactoryData } from "./utils/getFactoryData.js"
 
@@ -168,6 +169,9 @@ export async function toTrustSmartAccount(
         async encodeCalls(calls) {
             return encodeCallData(calls)
         },
+        async decodeCalls(callData) {
+            return decodeCallData(callData)
+        },
         async getNonce(args) {
             return getAccountNonce(client, {
                 address: await this.getAddress(),

package/accounts/trust/utils/decodeCallData.ts

@@ -0,0 +1,87 @@
+import { type Address, type Hex, decodeFunctionData } from "viem"
+
+export const decodeCallData = async (callData: `0x${string}`) => {
+    try {
+        const decodedBatch = decodeFunctionData({
+            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"
+                }
+            ],
+            data: callData
+        })
+
+        const calls: {
+            to: Address
+            data: Hex
+            value?: bigint
+        }[] = []
+
+        for (let i = 0; i < decodedBatch.args[0].length; i++) {
+            calls.push({
+                to: decodedBatch.args[0][i],
+                value: decodedBatch.args[1][i],
+                data: decodedBatch.args[2][i]
+            })
+        }
+
+        return calls
+    } catch (_) {}
+
+    const decodedSingle = decodeFunctionData({
+        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"
+            }
+        ],
+        data: callData
+    })
+
+    return [
+        {
+            to: decodedSingle.args[0],
+            value: decodedSingle.args[1],
+            data: decodedSingle.args[2]
+        }
+    ]
+}

package/package.json

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