Untitled

'use client';

import { createPublicClient, encodeFunctionData, http, parseAbi, toFunctionSelector } from "viem";
import { bundlerActions, ENTRYPOINT_ADDRESS_V07 } from "permissionless";

import { KERNEL_V3_1 } from "@zerodev/sdk/constants";
import { getValidatorAddress, signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
import { 
    PasskeyValidatorContractVersion, 
    toPasskeyValidator, 
    toWebAuthnKey, 
    WebAuthnMode 
} from "@zerodev/passkey-validator";

import { BUNDLER_URL, CHAIN, PASSKEY_SERVER_URL, PAYMASTER_RPC } from "@/constants/constants";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
import { createKernelAccount, createKernelAccountClient, createZeroDevPaymasterClient } from "@zerodev/sdk";

export const enableBackup = async () => {
    const publicClient = createPublicClient({
        chain: CHAIN,
        transport: http(BUNDLER_URL)
    });

    const webAuthnKey = await toWebAuthnKey({
        passkeyServerHeaders: {},
        passkeyName: 'Untitled',
        passkeyServerUrl: PASSKEY_SERVER_URL,
        mode: WebAuthnMode.Login
    });

    const passkeyValidator = await toPasskeyValidator(publicClient, {
        webAuthnKey,
        entryPoint: ENTRYPOINT_ADDRESS_V07,
        kernelVersion: KERNEL_V3_1,
        validatorContractVersion: PasskeyValidatorContractVersion.V0_0_2
    });
 
    const guardianPrivateKey = generatePrivateKey();
    const guardianSigner = privateKeyToAccount(guardianPrivateKey);

    const guardianValidator = await signerToEcdsaValidator(publicClient, {
        signer: guardianSigner,
        entryPoint: ENTRYPOINT_ADDRESS_V07,
        kernelVersion: KERNEL_V3_1
    });

    const recoveryExecutorAddress = '0x2f65dB8039fe5CAEE0a8680D2879deB800F31Ae1';
    const recoveryExecutorFunction = 'function doRecovery(address _validator, bytes calldata _data)';
    const recoveryExecutorSelector = toFunctionSelector(recoveryExecutorFunction);
    
    const account = await createKernelAccount(publicClient, {
        entryPoint: ENTRYPOINT_ADDRESS_V07,
        kernelVersion: KERNEL_V3_1,
        plugins: {
          sudo: passkeyValidator,
          regular: guardianValidator,
          action: {
            address: recoveryExecutorAddress,
            selector: recoveryExecutorSelector,
          },
        }
    });

    const kernelPaymaster = createZeroDevPaymasterClient({
        entryPoint: ENTRYPOINT_ADDRESS_V07,
        chain: CHAIN,
        transport: http(PAYMASTER_RPC)
    });
        
    const smartAccount = createKernelAccountClient({
        account,
        chain: CHAIN,
        bundlerTransport: http(BUNDLER_URL),
        entryPoint: ENTRYPOINT_ADDRESS_V07,
        middleware: {
            sponsorUserOperation: kernelPaymaster.sponsorUserOperation
        }
    });

    const data = encodeFunctionData({
        abi: parseAbi([recoveryExecutorFunction]),
        functionName: "doRecovery",
        args: [getValidatorAddress(ENTRYPOINT_ADDRESS_V07, KERNEL_V3_1), guardianSigner.address],
    });

    const userOpHash = await smartAccount.sendUserOperation({
        userOperation: {
          callData: await account.encodeCallData({
            to: recoveryExecutorAddress,
            data,
            value: BigInt(0)
          })
        },
    });
  
    const bundlerClient = smartAccount.extend(bundlerActions(ENTRYPOINT_ADDRESS_V07) as any) as any;
  
    const hash = await bundlerClient.waitForUserOperationReceipt({
        hash: userOpHash,
        timeout: 10000000000
    });
  
    console.log(hash);
};