eco-solver 0.0.1-security → 1.5.0

package/src/transaction/smart-wallets/kernel/create-kernel-client-v2.account.ts

@@ -0,0 +1,183 @@
+import { SmartAccountActions, SmartAccountClient } from 'permissionless'
+import {
+  KernelVersion,
+  toEcdsaKernelSmartAccount,
+  ToEcdsaKernelSmartAccountParameters,
+  ToEcdsaKernelSmartAccountReturnType,
+} from 'permissionless/accounts'
+import {
+  Account,
+  Chain,
+  Client,
+  ClientConfig,
+  createClient,
+  createWalletClient,
+  Hash,
+  LocalAccount,
+  OneOf,
+  Prettify,
+  RpcSchema,
+  SendTransactionParameters,
+  SendTransactionRequest,
+  Transport,
+  WalletClient,
+} from 'viem'
+import { SendUserOperationParameters } from 'viem/account-abstraction'
+import { encodeKernelExecuteCallData } from '@/transaction/smart-wallets/kernel/actions/encodeData.kernel'
+import { entryPointV_0_7 } from '@/transaction/smart-wallets/kernel/create.kernel.account'
+import { sendTransaction } from 'viem/actions'
+import { EthereumProvider } from 'permissionless/utils/toOwner'
+
+export type KernelAccountClientV2Config<
+  entryPointVersion extends '0.6' | '0.7',
+  kernelVersion extends KernelVersion<entryPointVersion>,
+  owner extends OneOf<
+    EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount
+  >,
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends ToEcdsaKernelSmartAccountReturnType<entryPointVersion> | undefined =
+    | ToEcdsaKernelSmartAccountReturnType<entryPointVersion>
+    | undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  ClientConfig<transport, chain, account, rpcSchema> &
+    ToEcdsaKernelSmartAccountParameters<entryPointVersion, kernelVersion, owner> & {
+      ownerAccount: Account
+    }
+>
+
+export type KernelAccountClientV2<
+  entryPointVersion extends '0.6' | '0.7',
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends ToEcdsaKernelSmartAccountReturnType<entryPointVersion> | undefined =
+    | ToEcdsaKernelSmartAccountReturnType<entryPointVersion>
+    | undefined,
+  client extends Client | undefined = undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  SmartAccountClient<transport, chain, account, client, rpcSchema> & {
+    ownerAccount: Account
+  }
+>
+
+export async function createKernelAccountClientV2<
+  entryPointVersion extends '0.6' | '0.7' = entryPointV_0_7,
+  owner extends OneOf<
+    EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount
+  > = LocalAccount,
+>(
+  _parameters: KernelAccountClientV2Config<
+    entryPointVersion,
+    KernelVersion<entryPointVersion>,
+    owner
+  >,
+): Promise<KernelAccountClientV2<entryPointVersion>> {
+  const { ownerAccount, ...parameters } = _parameters
+
+  const { key = 'kernelAccountClientV2', name = 'Kernel Account Client V2', transport } = parameters
+  const { account } = parameters
+
+  const walletClient = createWalletClient({
+    ...parameters,
+    account,
+    key,
+    name,
+    transport,
+  })
+
+  const kernelAccount = await toEcdsaKernelSmartAccount<
+    entryPointVersion,
+    KernelVersion<entryPointVersion>,
+    owner
+  >({
+    ...parameters,
+    client: walletClient,
+  })
+
+  const client = Object.assign(
+    createClient({
+      ...parameters,
+      account: kernelAccount,
+      chain: parameters.chain ?? walletClient?.chain,
+    }),
+    { ownerAccount },
+  )
+
+  return client.extend(kernelAccountV2Actions) as KernelAccountClientV2<entryPointVersion>
+}
+
+function kernelAccountV2Actions<
+  entryPointVersion extends '0.6' | '0.7',
+  TChain extends Chain | undefined = Chain | undefined,
+  account extends ToEcdsaKernelSmartAccountReturnType<entryPointVersion> | undefined =
+    | ToEcdsaKernelSmartAccountReturnType<entryPointVersion>
+    | undefined,
+>(
+  client: KernelAccountClientV2<entryPointVersion, Transport, TChain, account>,
+): Pick<SmartAccountActions<TChain, account>, 'sendTransaction'> {
+  return {
+    sendTransaction: (args) => sendTransactionWithSWC(client, args as any),
+  }
+}
+
+async function sendTransactionWithSWC<
+  entryPointVersion extends '0.6' | '0.7',
+  account extends ToEcdsaKernelSmartAccountReturnType<entryPointVersion> | undefined =
+    | ToEcdsaKernelSmartAccountReturnType<entryPointVersion>
+    | undefined,
+  chain extends Chain | undefined = Chain | undefined,
+  accountOverride extends ToEcdsaKernelSmartAccountReturnType<entryPointVersion> | undefined =
+    | ToEcdsaKernelSmartAccountReturnType<entryPointVersion>
+    | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  calls extends readonly unknown[] = readonly unknown[],
+  const request extends SendTransactionRequest<chain, chainOverride> = SendTransactionRequest<
+    chain,
+    chainOverride
+  >,
+>(
+  client: KernelAccountClientV2<entryPointVersion, Transport, chain, account>,
+  args:
+    | SendTransactionParameters<chain, account, chainOverride>
+    | SendUserOperationParameters<account, accountOverride, calls>,
+): Promise<Hash> {
+  const account = (args.account as Account) ?? client.account
+  if (account?.type !== 'smart') {
+    if (!('to' in args)) throw new Error('Unsupported args')
+    return sendTransaction(client, args as any)
+  }
+
+  let calls: calls
+  let request: request
+
+  if ('to' in args) {
+    const { data, maxFeePerGas, maxPriorityFeePerGas, to, value } =
+      args as SendTransactionParameters<chain, account, chainOverride>
+
+    calls = [{ to, data, value }] as unknown as calls
+    request = { maxFeePerGas, maxPriorityFeePerGas } as request
+  } else if ('calls' in args) {
+    calls = args.calls as unknown as calls
+    request = {} as request
+  } else {
+    throw new Error('Unsupported action in Kernel Client V2')
+  }
+
+  if (!client.account) {
+    throw new Error('Account not defined in Kernel Client V2')
+  }
+
+  const txs = calls.map((tx: any) => ({ to: tx.to, data: tx.data, value: tx.value }))
+  const kernelVersion = client.account.entryPoint.version == '0.6' ? '0.2.4' : '0.3.1'
+  const data = encodeKernelExecuteCallData({ calls: txs, kernelVersion })
+  return sendTransaction(client, {
+    ...(request as any),
+    data: data,
+    kzg: undefined,
+    to: client.account.address,
+    chain: client.chain,
+    account: client.ownerAccount,
+  })
+}

package/src/transaction/smart-wallets/kernel/create.kernel.account.ts

@@ -0,0 +1,270 @@
+import {
+  Account,
+  Chain,
+  createWalletClient,
+  encodeFunctionData,
+  encodePacked,
+  erc20Abi,
+  getAddress,
+  Hex,
+  LocalAccount,
+  OneOf,
+  publicActions,
+  Transport,
+  WalletClient,
+} from 'viem'
+import { KernelAccountClientConfig } from './kernel-account.config'
+import {
+  DeployFactoryArgs,
+  KernelAccountActions,
+  KernelAccountClient,
+} from './kernel-account.client'
+import { EthereumProvider } from 'permissionless/utils/toOwner'
+import { KernelVersion } from 'permissionless/accounts'
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator'
+import { KERNEL_V3_1 } from '@zerodev/sdk/constants'
+import { entryPoint07Address, EntryPointVersion } from 'viem/account-abstraction'
+import { createKernelAccount } from '@zerodev/sdk'
+import {
+  getAccount,
+  getOwnableExecutor,
+  GLOBAL_CONSTANTS,
+  installModule,
+  isModuleInstalled,
+} from '@rhinestone/module-sdk'
+import { Logger } from '@nestjs/common'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { OwnableExecutorAbi } from '@/contracts'
+
+export type entryPointV_0_7 = '0.7'
+
+/**
+ * Creates a kernel account client with a kernel account.
+ *
+ * @param parameters the kernel account client config
+ * @returns
+ */
+export async function createKernelAccountClient<
+  entryPointVersion extends '0.6' | '0.7' = entryPointV_0_7,
+  owner extends OneOf<
+    EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount
+  > = LocalAccount,
+>(
+  parameters: KernelAccountClientConfig<entryPointVersion, KernelVersion<entryPointVersion>, owner>,
+): Promise<{ client: KernelAccountClient<entryPointVersion>; args: DeployFactoryArgs }> {
+  const { key = 'kernelAccountClient', name = 'Kernel Account Client', transport } = parameters
+  const { account } = parameters
+
+  let walletClient = createWalletClient({
+    ...parameters,
+    account,
+    key,
+    name,
+    transport,
+  }) as KernelAccountClient<entryPointVersion>
+  const kernelVersion = KERNEL_V3_1
+  const entryPoint = {
+    address: entryPoint07Address,
+    version: '0.7' as EntryPointVersion,
+  }
+
+  const ecdsaValidator = await signerToEcdsaValidator(walletClient, {
+    signer: account as LocalAccount,
+    entryPoint: entryPoint!,
+    kernelVersion,
+  })
+
+  const kernelAccount = await createKernelAccount(walletClient, {
+    plugins: {
+      sudo: ecdsaValidator,
+    },
+    useMetaFactory: false,
+    entryPoint: entryPoint as any,
+    kernelVersion,
+  })
+
+  walletClient.kernelAccount = kernelAccount as any
+  walletClient.kernelAccountAddress = kernelAccount.address
+  walletClient = walletClient.extend(KernelAccountActions).extend(publicActions) as any
+
+  //conditionally deploys kernel account if it doesn't exist
+  const args = await walletClient.deployKernelAccount()
+  return { client: walletClient, args }
+}
+
+/**
+ * Adds a {@link OwnableExecutor} module to the kernel account. The module is used to
+ * execute transactions on behalf of the kernel account. Owner is usually
+ * a multisig safe account.
+ *
+ * @param client the kernel account client
+ * @param owner the owner to add to the kernel account, a multisig usually
+ */
+export async function addExecutorToKernelAccount<
+  entryPointVersion extends '0.6' | '0.7' = entryPointV_0_7,
+>(client: KernelAccountClient<entryPointVersion>, owner: Hex) {
+  const logger = getLogger()
+
+  // Ensure the owner is valid and checksummed
+  owner = getAddress(owner)
+
+  // Create the account object
+  const account = getAccount({
+    address: client.kernelAccount.address,
+    type: 'kernel',
+  })
+  const executor = getOwnableExecutor({
+    owner,
+  })
+
+  const executorInstalled = await isModuleInstalled({
+    client: client as any,
+    account: account,
+    module: executor,
+  })
+
+  logger.log(
+    EcoLogMessage.fromDefault({
+      message: `isModuleInstalled OwnableExecutor: ${executorInstalled}`,
+      properties: {
+        kernelAccount: client.kernelAccount.address,
+        owner,
+      },
+    }),
+  )
+
+  if (!executorInstalled) {
+    logger.log(
+      EcoLogMessage.fromDefault({
+        message: `installing OwnableExecutor`,
+        properties: {
+          kernelAccount: client.kernelAccount.address,
+          owner,
+        },
+      }),
+    )
+    const installExecutes = await installModule({
+      client: client as any,
+      account: account,
+      module: executor,
+    })
+
+    try {
+      const transactionHash = await client.execute(installExecutes as any)
+      const receipt = await client.waitForTransactionReceipt({
+        hash: transactionHash,
+        confirmations: 5,
+      })
+      logger.log(
+        EcoLogMessage.fromDefault({
+          message: `installed OwnableExecutor`,
+          properties: {
+            kernelAccount: client.kernelAccount.address,
+            owner,
+            transactionHash,
+            receipt,
+          },
+        }),
+      )
+    } catch (e) {
+      // Clients do not cache, so an install can go through but the
+      // client still tries to install it on a subsequent call
+      logger.error(
+        EcoLogMessage.fromDefault({
+          message: `install OwnableExecutor failed`,
+          properties: {
+            kernelAccount: client.kernelAccount.address,
+            owner,
+            error: e,
+          },
+        }),
+      )
+    }
+  }
+}
+
+/**
+ * Encodes the calldata for the OwnableExecutor executeOnOwnedAccount function in order to
+ * transfer an erc20 token owned by the kernel account.
+ * @param kernelAccountAddress the kernel account address
+ * @param tx the transfer transaction on the erc20 token to encode
+ * @returns
+ */
+export function getExecutorTransferData(
+  kernelAccountAddress: Hex,
+  tx: { to: Hex; amount: bigint; tokenAddress: Hex },
+) {
+  //Encode the transfer function of the ERC20 token
+  const transferCalldata = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'transfer',
+    args: [tx.to, tx.amount],
+  })
+
+  //Encode the calldata for the OwnableExecutor executeOnOwnedAccount function
+  const packed = encodePacked(
+    ['address', 'uint256', 'bytes'],
+    [tx.tokenAddress, BigInt(Number(0)), transferCalldata],
+  )
+
+  const executorCall = encodeFunctionData({
+    abi: OwnableExecutorAbi,
+    functionName: 'executeOnOwnedAccount',
+    args: [kernelAccountAddress, packed], //the owned account is the kernel account
+  })
+  return executorCall
+}
+
+/**
+ * Transfers an ERC20 token from an OwnableExecutor eip-7975 module. It
+ * calls the underlying `executeOnOwnedAccount` function of the module that then calls the
+ * owned Kernel wallet. Serves for generating the calldata needed for the transfer.
+ * Calldata should be executed on the executor contract.
+ *
+ * @param client the kernel account client
+ * @param tx the token tx data
+ */
+export async function executorTransferERC20Token<
+  entryPointVersion extends '0.6' | '0.7' = entryPointV_0_7,
+>(
+  client: KernelAccountClient<entryPointVersion>,
+  tx: { to: Hex; amount: bigint; tokenAddress: Hex },
+) {
+  const logger = getLogger()
+
+  //Encode the transfer function of the ERC20 token
+  const transferCalldata = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'transfer',
+    args: [tx.to, tx.amount],
+  })
+
+  //Encode the calldata for the OwnableExecutor executeOnOwnedAccount function
+  const packed = encodePacked(
+    ['address', 'uint256', 'bytes'],
+    [tx.tokenAddress, BigInt(Number(0)), transferCalldata],
+  )
+
+  // Simulate the contract call
+  const { request } = await client.simulateContract({
+    address: GLOBAL_CONSTANTS.OWNABLE_EXECUTOR_ADDRESS,
+    abi: OwnableExecutorAbi,
+    functionName: 'executeOnOwnedAccount',
+    args: [client.kernelAccount.address, packed], //the owned account is the kernel account
+    account: client.kernelAccount.client.account, //assumes the kernel account signer is the owner of the executor for the kernel contract
+  })
+
+  logger.log(
+    EcoLogMessage.fromDefault({
+      message: `simulated OwnableExecutor executeOnOwnedAccount token transfer`,
+      properties: {
+        kernelAccount: client.kernelAccount.address,
+        request,
+      },
+    }),
+  )
+}
+
+function getLogger() {
+  return new Logger('OwnableExecutor')
+}

package/src/transaction/smart-wallets/kernel/index.ts

@@ -0,0 +1,2 @@
+export * from './kernel-account.client'
+export * from './kernel-account.config'

package/src/transaction/smart-wallets/kernel/kernel-account-client-v2.service.ts

@@ -0,0 +1,90 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { ViemMultichainClientService } from '../../viem_multichain_client.service'
+import { entryPoint07Address } from 'viem/account-abstraction'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import {
+  Account,
+  Chain,
+  Hex,
+  LocalAccount,
+  OneOf,
+  Transport,
+  WalletClient,
+  zeroAddress,
+} from 'viem'
+import { KernelVersion } from 'permissionless/accounts'
+import { entryPointV_0_7 } from './create.kernel.account'
+import {
+  createKernelAccountClientV2,
+  KernelAccountClientV2,
+  KernelAccountClientV2Config,
+} from '@/transaction/smart-wallets/kernel/create-kernel-client-v2.account'
+import { EthereumProvider } from 'permissionless/utils/toOwner'
+import { SignerKmsService } from '@/sign/signer-kms.service'
+
+class KernelAccountClientV2ServiceBase<
+  entryPointVersion extends '0.6' | '0.7',
+  kernelVersion extends KernelVersion<entryPointVersion>,
+  owner extends OneOf<
+    EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount
+  > = LocalAccount,
+> extends ViemMultichainClientService<
+  KernelAccountClientV2<entryPointVersion>,
+  KernelAccountClientV2Config<entryPointVersion, kernelVersion, owner>
+> {
+  private logger = new Logger(KernelAccountClientV2ServiceBase.name)
+
+  constructor(
+    readonly ecoConfigService: EcoConfigService,
+    private readonly signerService: SignerKmsService,
+  ) {
+    super(ecoConfigService)
+  }
+
+  /**
+   * Returns the address of the wallet for the first solver in the config.
+   * @returns
+   */
+  public override async getAddress(): Promise<Hex> {
+    const solvers = this.ecoConfigService.getSolvers()
+    if (!solvers || Object.values(solvers).length == 0) {
+      return zeroAddress
+    }
+
+    const clientKernel = await this.getClient(Object.values(solvers)[0].chainID)
+    return clientKernel.account!.address
+  }
+
+  protected override async createInstanceClient(
+    configs: KernelAccountClientV2Config<entryPointVersion, kernelVersion, owner>,
+  ): Promise<KernelAccountClientV2<entryPointVersion>> {
+    return createKernelAccountClientV2(configs)
+  }
+
+  protected override async buildChainConfig(
+    chain: Chain,
+  ): Promise<KernelAccountClientV2Config<entryPointVersion, kernelVersion, owner>> {
+    const base = await super.buildChainConfig(chain)
+    return {
+      ...base,
+      ownerAccount: this.signerService.getAccount(),
+      useMetaFactory: false,
+      entryPoint: {
+        address: entryPoint07Address,
+        version: '0.7' as entryPointVersion,
+      },
+      owners: [this.signerService.getAccount() as owner],
+      index: 0n, // optional
+    }
+  }
+}
+
+@Injectable()
+export class KernelAccountClientV2Service extends KernelAccountClientV2ServiceBase<
+  entryPointV_0_7,
+  KernelVersion<entryPointV_0_7>
+> {
+  constructor(ecoConfigService: EcoConfigService, signerService: SignerKmsService) {
+    super(ecoConfigService, signerService)
+  }
+}

package/src/transaction/smart-wallets/kernel/kernel-account-client.service.ts

@@ -0,0 +1,107 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { ViemMultichainClientService } from '../../viem_multichain_client.service'
+import { entryPoint07Address } from 'viem/account-abstraction'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import {
+  Account,
+  Chain,
+  Hex,
+  LocalAccount,
+  OneOf,
+  Transport,
+  WalletClient,
+  zeroAddress,
+} from 'viem'
+import { KernelAccountClientConfig } from './kernel-account.config'
+import { KernelVersion } from 'permissionless/accounts'
+import {
+  addExecutorToKernelAccount,
+  createKernelAccountClient,
+  entryPointV_0_7,
+} from './create.kernel.account'
+import { KernelAccountClient } from './kernel-account.client'
+import { EthereumProvider } from 'permissionless/utils/toOwner'
+import { EcoLogMessage } from '../../../common/logging/eco-log-message'
+import { SignerKmsService } from '@/sign/signer-kms.service'
+
+@Injectable()
+export class KernelAccountClientServiceBase<
+  entryPointVersion extends '0.6' | '0.7',
+  kernelVersion extends KernelVersion<entryPointVersion>,
+  owner extends OneOf<
+    EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount
+  >,
+> extends ViemMultichainClientService<
+  KernelAccountClient<entryPointVersion>,
+  KernelAccountClientConfig<entryPointVersion, kernelVersion, owner>
+> {
+  private logger = new Logger(KernelAccountClientServiceBase.name)
+
+  constructor(
+    readonly ecoConfigService: EcoConfigService,
+    private readonly signerService: SignerKmsService,
+  ) {
+    super(ecoConfigService)
+  }
+
+  protected override async createInstanceClient(
+    configs: KernelAccountClientConfig<entryPointVersion, kernelVersion, owner>,
+  ): Promise<KernelAccountClient<entryPointVersion>> {
+    const { client, args } = await createKernelAccountClient(configs)
+    if (args && args.deployReceipt) {
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `Deploying Kernel Account`,
+          properties: {
+            ...args,
+            kernelAccount: client.kernelAccount.address,
+          },
+        }),
+      )
+    }
+    //Conditionally adds an OwnableExecutor to the Kernel Account
+    await addExecutorToKernelAccount(client, this.ecoConfigService.getSafe().owner)
+    return client
+  }
+
+  protected override async buildChainConfig(
+    chain: Chain,
+  ): Promise<KernelAccountClientConfig<entryPointVersion, kernelVersion, owner>> {
+    const base = await super.buildChainConfig(chain)
+    return {
+      ...base,
+      account: this.signerService.getAccount(),
+      useMetaFactory: false,
+      entryPoint: {
+        address: entryPoint07Address,
+        version: '0.7' as entryPointVersion,
+      },
+      owners: [this.signerService.getAccount() as owner],
+      index: 0n, // optional
+    }
+  }
+  /**
+   * Returns the address of the wallet for the first solver in the config.
+   * @returns
+   */
+  public override async getAddress(): Promise<Hex> {
+    const solvers = this.ecoConfigService.getSolvers()
+    if (!solvers || Object.values(solvers).length == 0) {
+      return zeroAddress
+    }
+
+    const clientKernel = await this.getClient(Object.values(solvers)[0].chainID)
+    return clientKernel.kernelAccount?.address
+  }
+}
+
+@Injectable()
+export class KernelAccountClientService extends KernelAccountClientServiceBase<
+  entryPointV_0_7,
+  KernelVersion<entryPointV_0_7>,
+  LocalAccount
+> {
+  constructor(ecoConfigService: EcoConfigService, signerService: SignerKmsService) {
+    super(ecoConfigService, signerService)
+  }
+}