eco-solver 0.0.1-security → 1.5.0

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

@@ -0,0 +1,105 @@
+import {
+  Account,
+  Chain,
+  createPublicClient,
+  Hex,
+  http,
+  Prettify,
+  RpcSchema,
+  Transport,
+  WalletRpcSchema,
+} from 'viem'
+import { ExecuteSmartWalletArgs, SmartWalletClient } from '../smart-wallet.types'
+import { ToEcdsaKernelSmartAccountReturnType } from 'permissionless/accounts'
+import { KernelWalletActions } from './kernel-account.config'
+import { encodeKernelExecuteCallData } from './actions/encodeData.kernel'
+
+export type DeployFactoryArgs = {
+  factory?: Hex | undefined
+  factoryData?: Hex | undefined
+  deployReceipt?: Hex | undefined
+  chainID?: number
+}
+
+export type KernelAccountClient<
+  entryPointVersion extends '0.6' | '0.7',
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  SmartWalletClient<
+    transport,
+    chain,
+    account,
+    rpcSchema extends RpcSchema ? [...WalletRpcSchema, ...rpcSchema] : WalletRpcSchema
+  > & {
+    kernelAccount: ToEcdsaKernelSmartAccountReturnType<entryPointVersion>
+    kernelAccountAddress: Hex
+  }
+>
+
+export function KernelAccountActions<
+  entryPointVersion extends '0.6' | '0.7',
+  transport extends Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>(client: KernelAccountClient<entryPointVersion, transport, chain, account>): KernelWalletActions {
+  return {
+    execute: (args) => execute(client, args),
+    deployKernelAccount: () => deployKernelAccount(client),
+  }
+}
+
+async function execute<
+  entryPointVersion extends '0.6' | '0.7',
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: KernelAccountClient<entryPointVersion, Transport, chain, account>,
+  transactions: ExecuteSmartWalletArgs,
+): Promise<Hex> {
+  const calls = transactions.map((tx) => ({ to: tx.to, data: tx.data, value: tx.value }))
+  const kernelVersion = client.kernelAccount.entryPoint.version == '0.6' ? '0.2.4' : '0.3.1'
+  const data = encodeKernelExecuteCallData({ calls, kernelVersion })
+  return client.sendTransaction({
+    data: data,
+    kzg: undefined,
+    to: client.kernelAccount.address,
+    chain: client.chain as Chain,
+    account: client.account as Account,
+  })
+}
+
+async function deployKernelAccount<
+  entryPointVersion extends '0.6' | '0.7',
+  transport extends Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>(
+  client: KernelAccountClient<entryPointVersion, transport, chain, account>,
+): Promise<DeployFactoryArgs> {
+  const args: DeployFactoryArgs = {}
+
+  const publicClient = createPublicClient({
+    chain: client.chain,
+    transport: http(),
+  })
+  const code = await publicClient.getCode({ address: client.kernelAccount.address })
+
+  if (!code) {
+    const fa = await client.kernelAccount.getFactoryArgs()
+    args.factory = fa.factory
+    args.factoryData = fa.factoryData
+    args.chainID = client.chain?.id
+    args.deployReceipt = await client.sendTransaction({
+      data: args.factoryData,
+      kzg: undefined,
+      to: args.factory,
+      chain: client.chain as Chain,
+      account: client.account as Account,
+    })
+    await client.waitForTransactionReceipt({ hash: args.deployReceipt, confirmations: 5 })
+  }
+  return args
+}

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

@@ -0,0 +1,34 @@
+import { KernelVersion, ToEcdsaKernelSmartAccountParameters } from 'permissionless/accounts'
+import {
+  Account,
+  Chain,
+  LocalAccount,
+  OneOf,
+  Prettify,
+  Transport,
+  WalletClient,
+  WalletClientConfig,
+} from 'viem'
+import { SmartWalletActions } from '../smart-wallet.types'
+import { DeployFactoryArgs } from './kernel-account.client'
+import { EthereumProvider } from 'permissionless/utils/toOwner'
+
+export type KernelAccountClientConfig<
+  entryPointVersion extends '0.6' | '0.7',
+  kernelVersion extends KernelVersion<entryPointVersion>,
+  owner extends OneOf<
+    EthereumProvider | WalletClient<Transport, Chain | undefined, Account> | LocalAccount
+  >,
+> = WalletClientConfig &
+  ToEcdsaKernelSmartAccountParameters<entryPointVersion, kernelVersion, owner>
+
+export type KernelWalletActions = Prettify<
+  SmartWalletActions & {
+    deployKernelAccount: () => Promise<DeployFactoryArgs>
+  }
+>
+
+export const isKernelV2 = (version: KernelVersion<'0.6' | '0.7'>): boolean => {
+  const regex = /0\.2\.\d+/
+  return regex.test(version)
+}

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

@@ -0,0 +1,19 @@
+import { createWalletClient, publicActions } from 'viem'
+import { SimpleAccountActions, SimpleAccountClient } from './simple-account.client'
+import { SimpleAccountClientConfig } from './simple-account.config'
+
+export function createSimpleAccountClient(
+  parameters: SimpleAccountClientConfig,
+): SimpleAccountClient {
+  const { key = 'simpleAccountClient', name = 'Simple Account Client', transport } = parameters
+
+  let client = createWalletClient({
+    ...parameters,
+    key,
+    name,
+    transport,
+  }) as SimpleAccountClient
+  client.simpleAccountAddress = parameters.simpleAccountAddress
+  client = client.extend(SimpleAccountActions).extend(publicActions) as any
+  return client
+}

package/src/transaction/smart-wallets/simple-account/index.ts

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

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

@@ -0,0 +1,42 @@
+import { Injectable } from '@nestjs/common'
+import { EcoConfigService } from '../../../eco-configs/eco-config.service'
+import { ViemMultichainClientService } from '../../viem_multichain_client.service'
+import { SimpleAccountClient, SimpleAccountClientConfig } from '.'
+import { EcoError } from '../../../common/errors/eco-error'
+import { createSimpleAccountClient } from './create.simple.account'
+import { SignerService } from '../../../sign/signer.service'
+import { Chain } from 'viem'
+
+@Injectable()
+export class SimpleAccountClientService extends ViemMultichainClientService<
+  SimpleAccountClient,
+  SimpleAccountClientConfig
+> {
+  constructor(
+    readonly ecoConfigService: EcoConfigService,
+    private readonly signerService: SignerService,
+  ) {
+    super(ecoConfigService)
+  }
+
+  protected override async createInstanceClient(
+    configs: SimpleAccountClientConfig,
+  ): Promise<SimpleAccountClient> {
+    return createSimpleAccountClient(configs)
+  }
+
+  protected override async buildChainConfig(chain: Chain): Promise<SimpleAccountClientConfig> {
+    const base = await super.buildChainConfig(chain)
+    const simpleAccountConfig = this.ecoConfigService.getEth().simpleAccount
+
+    if (!simpleAccountConfig) {
+      throw EcoError.InvalidSimpleAccountConfig()
+    }
+
+    return {
+      ...base,
+      simpleAccountAddress: simpleAccountConfig.walletAddr,
+      account: this.signerService.getAccount(),
+    }
+  }
+}

package/src/transaction/smart-wallets/simple-account/simple-account.client.ts

@@ -0,0 +1,83 @@
+import {
+  encodeFunctionData,
+  Hex,
+  Transport,
+  Chain,
+  Account,
+  RpcSchema,
+  Prettify,
+  WalletRpcSchema,
+} from 'viem'
+import { SimpleAccountAbi } from '../../../contracts'
+import {
+  ExecuteSmartWalletArgs,
+  SmartWalletActions,
+  SmartWalletClient,
+} from '../smart-wallet.types'
+import { throwIfValueSendInBatch } from '../utils'
+
+export type SimpleAccountClient<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  SmartWalletClient<
+    transport,
+    chain,
+    account,
+    rpcSchema extends RpcSchema ? [...WalletRpcSchema, ...rpcSchema] : WalletRpcSchema
+  > & {
+    simpleAccountAddress: Hex
+  }
+>
+
+export function SimpleAccountActions<
+  transport extends Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>(
+  client: SimpleAccountClient<transport, chain, account>,
+): Omit<SmartWalletActions, 'deployKernelAccount'> {
+  return {
+    execute: (args) => execute(client, args),
+  }
+}
+
+async function execute<chain extends Chain | undefined, account extends Account | undefined>(
+  client: SimpleAccountClient<Transport, chain, account>,
+  transactions: ExecuteSmartWalletArgs,
+): Promise<Hex> {
+  if (transactions.length === 1) {
+    const [tx] = transactions
+
+    const data = encodeFunctionData({
+      abi: SimpleAccountAbi,
+      functionName: 'execute',
+      args: [tx.to, tx.value || 0n, tx.data!],
+    })
+
+    return client.sendTransaction({
+      data: data,
+      kzg: undefined,
+      to: client.simpleAccountAddress,
+      chain: client.chain as Chain,
+      account: client.account as Account,
+    })
+  }
+  throwIfValueSendInBatch(transactions)
+
+  const data = encodeFunctionData({
+    abi: SimpleAccountAbi,
+    functionName: 'executeBatch',
+    args: [transactions.map((tx) => tx.to), transactions.map((tx) => tx.data!)],
+  })
+
+  return client.sendTransaction({
+    data: data,
+    kzg: undefined,
+    to: client.simpleAccountAddress,
+    chain: client.chain as Chain,
+    account: client.account as Account,
+  })
+}

package/src/transaction/smart-wallets/simple-account/simple-account.config.ts

@@ -0,0 +1,5 @@
+import type { Hex, WalletClientConfig } from 'viem'
+
+export interface SimpleAccountClientConfig extends WalletClientConfig {
+  simpleAccountAddress: Hex
+}

package/src/transaction/smart-wallets/smart-wallet.types.ts

@@ -0,0 +1,38 @@
+import {
+  WalletClient,
+  Hex,
+  Transport,
+  Chain,
+  Account,
+  RpcSchema,
+  Prettify,
+  WalletRpcSchema,
+  PublicActions,
+} from 'viem'
+import { DeployFactoryArgs } from './kernel'
+
+// The type that simple account executes arrays of
+export type ExecuteSmartWalletArg = { to: Hex; data?: Hex; value?: bigint }
+
+export type ExecuteSmartWalletArgs = ExecuteSmartWalletArg[]
+
+export type SmartWalletActions = {
+  execute: (args: ExecuteSmartWalletArgs) => Promise<Hex>
+  deployKernelAccount: () => Promise<DeployFactoryArgs>
+}
+
+export type SmartWalletClient<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  rpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  WalletClient<
+    transport,
+    chain,
+    account,
+    rpcSchema extends RpcSchema ? [...WalletRpcSchema, ...rpcSchema] : WalletRpcSchema
+  > &
+    PublicActions<transport, chain> &
+    SmartWalletActions
+>

package/src/transaction/smart-wallets/utils.ts

@@ -0,0 +1,14 @@
+import { ExecuteSmartWalletArgs } from './smart-wallet.types'
+
+/**
+ * Throws if we don`t support value send in batch transactions, {@link SimpleAccountClient}
+ * @param transactions the transactions to execute
+ */
+export function throwIfValueSendInBatch(transactions: ExecuteSmartWalletArgs) {
+  if (
+    transactions.length > 1 &&
+    transactions.some((tx) => tx.value !== undefined || tx.value !== 0n)
+  ) {
+    throw new Error('Value send is not support value in batch transactions')
+  }
+}

package/src/transaction/transaction.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common'
+import { SignModule } from '../sign/sign.module'
+import { SimpleAccountClientService } from './smart-wallets/simple-account/simple-account-client.service'
+import { MultichainPublicClientService } from './multichain-public-client.service'
+import { ViemMultichainClientService } from './viem_multichain_client.service'
+import { KernelAccountClientService } from './smart-wallets/kernel/kernel-account-client.service'
+import { KernelAccountClientV2Service } from '@/transaction/smart-wallets/kernel/kernel-account-client-v2.service'
+
+@Module({
+  imports: [SignModule],
+  providers: [
+    SimpleAccountClientService,
+    MultichainPublicClientService,
+    ViemMultichainClientService,
+    KernelAccountClientService,
+    KernelAccountClientV2Service,
+  ],
+  exports: [
+    SimpleAccountClientService,
+    MultichainPublicClientService,
+    KernelAccountClientService,
+    KernelAccountClientV2Service,
+  ],
+})
+export class TransactionModule {}

package/src/transaction/viem_multichain_client.service.ts

@@ -0,0 +1,100 @@
+import { Injectable, OnModuleInit } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { Chain, Client, ClientConfig, createClient, extractChain, Hex, zeroAddress } from 'viem'
+import { EcoError } from '../common/errors/eco-error'
+import { ChainsSupported } from '../common/chains/supported'
+import { getTransport } from '../common/chains/transport'
+
+@Injectable()
+export class ViemMultichainClientService<T extends Client, V extends ClientConfig>
+  implements OnModuleInit
+{
+  readonly instances: Map<number, T> = new Map()
+
+  protected supportedAlchemyChainIds: number[] = []
+  protected apiKey: string
+  protected pollingInterval: number
+
+  constructor(readonly ecoConfigService: EcoConfigService) {}
+
+  onModuleInit() {
+    this.setChainConfigs()
+  }
+
+  async getClient(id: number): Promise<T> {
+    if (!this.isSupportedNetwork(id)) {
+      throw EcoError.AlchemyUnsupportedNetworkIDError(id)
+    }
+    return this.loadInstance(id)
+  }
+
+  private setChainConfigs() {
+    const alchemyConfigs = this.ecoConfigService.getAlchemy()
+    this.supportedAlchemyChainIds = alchemyConfigs.networks.map((n) => n.id)
+    this.apiKey = alchemyConfigs.apiKey
+    this.pollingInterval = this.ecoConfigService.getEth().pollingInterval
+  }
+
+  private async loadInstance(chainID: number): Promise<T> {
+    if (!this.instances.has(chainID)) {
+      const client = await this.createInstanceClient(await this.getChainConfig(chainID))
+      this.instances.set(chainID, client)
+    }
+    return this.instances.get(chainID)!
+  }
+
+  protected async createInstanceClient(configs: V): Promise<T> {
+    //@ts-expect-error client mismatch on property definition
+    return createClient(configs)
+  }
+
+  /**
+   * Use overrides if they exist -- otherwise use the default settings.
+   * @param chainID
+   * @returns
+   */
+  public async getChainConfig(chainID: number): Promise<V> {
+    const chain = extractChain({
+      chains: ChainsSupported,
+      id: chainID,
+    })
+
+    if (chain) {
+      return this.buildChainConfig(chain)
+    } else {
+      throw EcoError.UnsupportedChainError(chain[0])
+    }
+  }
+
+  protected async buildChainConfig(chain: Chain): Promise<V> {
+    //only pass api key if chain is supported by alchemy, otherwise it'll be incorrectly added to other rpcs
+    const apiKey = this.supportedAlchemyChainIds.includes(chain.id) ? this.apiKey : undefined
+    const rpcTransport = getTransport(chain, apiKey)
+    return {
+      transport: rpcTransport,
+      chain: chain,
+      pollingInterval: this.pollingInterval,
+    } as V
+  }
+
+  /**
+   * Returns the address of the wallet for the first solver in the config.
+   * @returns
+   */
+  protected async getAddress(): Promise<Hex> {
+    const solvers = this.ecoConfigService.getSolvers()
+    if (!solvers || Object.values(solvers).length == 0) {
+      return zeroAddress
+    }
+
+    const wallet = await this.getClient(Object.values(solvers)[0].chainID)
+    return wallet.account?.address || zeroAddress
+  }
+
+  private isSupportedNetwork(chainID: number): boolean {
+    return (
+      this.supportedAlchemyChainIds.includes(chainID) ||
+      ChainsSupported.some((chain) => chain.id === chainID)
+    )
+  }
+}

package/src/transforms/viem-address.decorator.ts

@@ -0,0 +1,14 @@
+import { Transform } from 'class-transformer'
+import { getAddress } from 'viem'
+
+/**
+ * Decorator that transforms dtos to chechsum addresses or throws
+ */
+export function ViemAddressTransform() {
+  return Transform(({ value }) => {
+    if (typeof value === 'string') {
+      return getAddress(value) // validate and checksum
+    }
+    return value // Return as-is if not a string
+  })
+}

package/src/utils/bigint.ts

@@ -0,0 +1,44 @@
+/**
+ * Mathb is a utility class for bigint operations.
+ */
+export class Mathb {
+  /**
+   * Get the absolute value of a bigint.
+   * @param x the number
+   * @returns
+   */
+  static abs(x: bigint): bigint {
+    return x < 0 ? -x : x
+  }
+
+  /**
+   * Get the minimum of two bigints.
+   * @param x first bigint
+   * @param y second bigint
+   * @returns
+   */
+  static min(x: bigint, y: bigint): bigint {
+    return x < y ? x : y
+  }
+
+  /**
+   * Get the maximum of two bigints.
+   * @param x first bigint
+   * @param y second bigint
+   * @returns
+   */
+  static max(x: bigint, y: bigint): bigint {
+    return x > y ? x : y
+  }
+
+  /**
+   * Compares two bigints. Returns 0 if they are equal, 1 if x is greater than y, and -1 if x is less than y.
+   * Usefull for sorting.
+   * @param x first bigint
+   * @param y second bigint
+   * @returns
+   */
+  static compare(x: bigint, y: bigint): number {
+    return x === y ? 0 : x > y ? 1 : -1
+  }
+}

package/src/utils/types.ts

@@ -0,0 +1,18 @@
+/**
+ * The type of an array
+ */
+export type GetElementType<T> = T extends (infer U)[] ? U : never
+
+/**
+ * Removes the readonly modifier entire object
+ */
+export type Mutable<T> = {
+  -readonly [K in keyof T]: T[K]
+}
+
+/**
+ * Removes the readonly modifier from a field
+ */
+export type MutableField<T, K extends keyof T> = Omit<T, K> & {
+  -readonly [P in K]: T[P]
+}