startale-aa-sdk/dist/_esm/clients/decorators/erc7579/supportsModule.js

SDK for startale account integration with support for account abstraction, ERC-7579, ERC-4337.

import { ContractFunctionExecutionError, decodeFunctionResult, encodeFunctionData } from "viem";
import { call, readContract } from "viem/actions";
import { getAction } from "viem/utils";
import { parseAccount } from "viem/utils";
import { AccountNotFoundError } from "../../../account/utils/AccountNotFound.js";
const abi = [
    {
        name: "supportsModule",
        type: "function",
        stateMutability: "view",
        inputs: [
            {
                type: "uint256",
                name: "moduleTypeId"
            }
        ],
        outputs: [
            {
                type: "bool"
            }
        ]
    }
];
/**
 * Parses a module type to its corresponding ID.
 *
 * @param type - The module type to parse.
 * @returns The corresponding bigint ID for the module type.
 * @throws {Error} If an invalid module type is provided.
 */
export function parseModuleTypeId(type) {
    switch (type) {
        case "validator":
            return BigInt(1);
        case "executor":
            return BigInt(2);
        case "fallback":
            return BigInt(3);
        case "hook":
            return BigInt(4);
        default:
            throw new Error(`Invalid module type: ${type}`);
    }
}
/**
 * Checks if a smart account supports a specific module type.
 *
 * @param client - The client instance.
 * @param args - Parameters including the smart account and module type to check.
 * @returns A boolean indicating whether the module type is supported.
 * @throws {AccountNotFoundError} If the account is not found.
 *
 * @example
 * import { supportsModule } from 'startale-aa-sdk'
 *
 * const isSupported = await supportsModule(startaleClient, {
 *   type: 'executor'
 * })
 * console.log(isSupported) // true or false
 */
export async function supportsModule(client, args) {
    const { account: account_ = client.account } = args;
    // Review: all docs paths.
    if (!account_) {
        throw new AccountNotFoundError({
            docsPath: "/startale-client/methods#sendtransaction"
        });
    }
    const account = parseAccount(account_);
    const publicClient = account.client;
    const [supportsModuleRead] = await toSupportsModuleReads(account, args);
    try {
        return await getAction(publicClient, readContract, "readContract")(supportsModuleRead);
    }
    catch (error) {
        if (error instanceof ContractFunctionExecutionError) {
            const { factory, factoryData } = await account.getFactoryArgs();
            const result = await getAction(publicClient, call, "call")({
                factory: factory,
                factoryData: factoryData,
                to: account.address,
                data: encodeFunctionData({
                    abi,
                    functionName: "supportsModule",
                    args: [parseModuleTypeId(args.type)]
                })
            });
            if (!result || !result.data) {
                throw new Error("accountId result is empty");
            }
            return decodeFunctionResult({
                abi,
                functionName: "supportsModule",
                data: result.data
            });
        }
        throw error;
    }
}
export const toSupportsModuleReads = async (account, { type }) => [
    {
        abi,
        functionName: "supportsModule",
        args: [parseModuleTypeId(type)],
        address: account.address
    }
];
//# sourceMappingURL=supportsModule.js.map