@alchemy/aa-core/dist/esm/account/simple.js

viem based SDK that enables interactions with ERC-4337 Smart Accounts. ABIs are based off the definitions generated in @account-abstraction/contracts

import { concatHex, encodeFunctionData, isHex, } from "viem";
import { SimpleAccountAbi_v6 } from "../abis/SimpleAccountAbi_v6.js";
import { SimpleAccountAbi_v7 } from "../abis/SimpleAccountAbi_v7.js";
import { SimpleAccountFactoryAbi } from "../abis/SimpleAccountFactoryAbi.js";
import { createBundlerClient } from "../client/bundlerClient.js";
import { defaultEntryPointVersion, getEntryPoint, } from "../entrypoint/index.js";
import { AccountRequiresOwnerError } from "../errors/account.js";
import { getDefaultSimpleAccountFactoryAddress } from "../utils/defaults.js";
import { BaseSmartContractAccount } from "./base.js";
import { SimpleSmartAccountParamsSchema } from "./schema.js";
import { toSmartContractAccount, } from "./smartContractAccount.js";
class SimpleSmartContractAccount extends BaseSmartContractAccount {
    constructor(params) {
        SimpleSmartAccountParamsSchema().parse(params);
        const client = createBundlerClient({
            transport: params.transport,
            chain: params.chain,
        });
        super({ ...params, rpcClient: client });
        Object.defineProperty(this, "index", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "entryPointVersion", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.signer = params.signer;
        this.index = params.salt ?? 0n;
        this.entryPointVersion =
            params.entryPointVersion ?? defaultEntryPointVersion;
    }
    getDummySignature() {
        return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
    }
    async encodeExecute(target, value, data) {
        return encodeFunctionData({
            abi: this.entryPointVersion === "0.6.0"
                ? SimpleAccountAbi_v6
                : SimpleAccountAbi_v7,
            functionName: "execute",
            args: [target, value, data],
        });
    }
    async encodeBatchExecute(txs) {
        const [targets, datas] = txs.reduce((accum, curr) => {
            accum[0].push(curr.target);
            accum[1].push(curr.data);
            return accum;
        }, [[], []]);
        return encodeFunctionData({
            abi: this.entryPointVersion === "0.6.0"
                ? SimpleAccountAbi_v6
                : SimpleAccountAbi_v7,
            functionName: "executeBatch",
            args: [targets, datas],
        });
    }
    signMessage(msg) {
        return this.signer.signMessage(typeof msg === "string" && !isHex(msg) ? msg : { raw: msg });
    }
    async getAccountInitCode() {
        return concatHex([
            this.factoryAddress,
            encodeFunctionData({
                abi: SimpleAccountFactoryAbi,
                functionName: "createAccount",
                args: [await this.signer.getAddress(), this.index],
            }),
        ]);
    }
}
export async function createSimpleSmartAccount({ chain, entryPoint = getEntryPoint(chain), factoryAddress = getDefaultSimpleAccountFactoryAddress(chain, entryPoint.version), ...params }) {
    if (!params.signer)
        throw new AccountRequiresOwnerError("SimpleAccount");
    const simpleAccount = new SimpleSmartContractAccount(SimpleSmartAccountParamsSchema().parse({
        chain,
        entryPointAddress: entryPoint.address,
        factoryAddress,
        ...params,
    }));
    const parsedParams = SimpleSmartAccountParamsSchema().parse({
        chain,
        entryPointAddress: entryPoint.address,
        entryPointVersion: entryPoint.version,
        factoryAddress,
        ...params,
    });
    const base = await toSmartContractAccount({
        source: "SimpleAccount",
        transport: params.transport,
        chain,
        encodeBatchExecute: simpleAccount.encodeBatchExecute.bind(simpleAccount),
        encodeExecute: (tx) => simpleAccount.encodeExecute.bind(simpleAccount)(tx.target, tx.value ?? 0n, tx.data),
        entryPoint,
        getAccountInitCode: async () => {
            if (parsedParams.initCode)
                return parsedParams.initCode;
            return simpleAccount.getAccountInitCode();
        },
        getDummySignature: simpleAccount.getDummySignature.bind(simpleAccount),
        signMessage: ({ message }) => simpleAccount.signMessage(typeof message === "string" ? message : message.raw),
        signTypedData: simpleAccount.signTypedData.bind(simpleAccount),
        accountAddress: parsedParams.accountAddress,
    });
    return {
        ...base,
        getSigner: () => simpleAccount.getSigner(),
    };
}
//# sourceMappingURL=simple.js.map