@gelatocloud/gasless 0.0.0

package/account/adapters/gelato/index.ts

@@ -0,0 +1,216 @@
+import {
+  type Account,
+  type Chain,
+  type Client,
+  encodeFunctionData,
+  encodePacked,
+  type JsonRpcAccount,
+  type LocalAccount,
+  type StateOverride,
+  type Transport,
+  type TypedDataDefinition
+} from 'viem';
+import {
+  entryPoint08Abi,
+  entryPoint08Address,
+  getUserOperationTypedData,
+  type SmartAccount
+} from 'viem/account-abstraction';
+import {
+  estimateGas,
+  getCode,
+  readContract,
+  signMessage,
+  signTypedData,
+  signAuthorization as viem_signAuthorization
+} from 'viem/actions';
+import { encodeCalls } from 'viem/experimental/erc7821';
+import { delegationCode, delegationGas, estimateL1Fee } from '../../utils/index.js';
+import type { GelatoSmartAccountImplementation } from '../types/index.js';
+import { delegationAbi, simulationAbi, simulationBytecode } from './abi.js';
+import {
+  EXECUTION_MODE_OP_DATA,
+  GELATO_DELEGATION_ADDRESS,
+  GELATO_DELEGATION_NAME,
+  GELATO_DELEGATION_VERSION,
+  STUB_SIGNATURE
+} from './constants.js';
+
+export type GelatoSmartAccountParameters = {
+  client: Client<Transport, Chain, JsonRpcAccount | LocalAccount | undefined>;
+  owner: Account;
+};
+
+export type GelatoSmartAccountReturnType = SmartAccount<
+  GelatoSmartAccountImplementation<typeof entryPoint08Abi, '0.8'>
+>;
+
+export const toGelatoSmartAccount = (
+  parameters: GelatoSmartAccountParameters
+): GelatoSmartAccountReturnType => {
+  const { client, owner } = parameters;
+
+  let deployed = false;
+  const isDeployed = async () => {
+    if (deployed) {
+      return true;
+    }
+
+    const code = await getCode(client, { address: owner.address });
+
+    deployed =
+      code !== undefined &&
+      code.toLowerCase() === delegationCode(GELATO_DELEGATION_ADDRESS).toLowerCase();
+
+    return deployed;
+  };
+
+  const getNonce = async (parameters?: { key?: bigint }) =>
+    readContract(client, {
+      abi: delegationAbi,
+      address: owner.address,
+      args: [parameters?.key ?? 0n],
+      functionName: 'getNonce',
+      stateOverride: (await isDeployed())
+        ? undefined
+        : [
+            {
+              address: owner.address,
+              code: delegationCode(GELATO_DELEGATION_ADDRESS)
+            }
+          ]
+    });
+
+  return {
+    address: owner.address,
+    authorization: {
+      account: undefined as never,
+      address: GELATO_DELEGATION_ADDRESS
+    },
+    chain: client.chain,
+    client,
+    encodeCallData: async (parameters) => {
+      const { calls, nonce } = parameters;
+
+      const signature = await signTypedData(client, {
+        account: owner,
+        domain: {
+          chainId: client.chain.id,
+          name: GELATO_DELEGATION_NAME,
+          verifyingContract: owner.address,
+          version: GELATO_DELEGATION_VERSION
+        },
+        message: {
+          calls: calls.map((call) => ({
+            data: call.data ?? '0x',
+            to: call.to,
+            value: call.value ?? 0n
+          })),
+          mode: EXECUTION_MODE_OP_DATA,
+          nonce
+        },
+        primaryType: 'Execute',
+        types: {
+          Call: [
+            { name: 'to', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'data', type: 'bytes' }
+          ],
+          Execute: [
+            { name: 'mode', type: 'bytes32' },
+            { name: 'calls', type: 'Call[]' },
+            { name: 'nonce', type: 'uint256' }
+          ]
+        }
+      });
+
+      const nonceKey = nonce >> 64n;
+
+      const opData = encodePacked(['uint192', 'bytes'], [nonceKey, signature]);
+
+      return encodeFunctionData({
+        abi: delegationAbi,
+        args: [EXECUTION_MODE_OP_DATA, encodeCalls(calls, opData)],
+        functionName: 'execute'
+      });
+    },
+    encodeCalls: async (calls) => encodeCalls(calls),
+    entryPoint: {
+      abi: entryPoint08Abi,
+      address: entryPoint08Address,
+      version: '0.8'
+    },
+    estimate: async (parameters) => {
+      const opData = encodePacked(['uint192', 'bytes'], [0n, STUB_SIGNATURE]);
+
+      const data = encodeFunctionData({
+        abi: simulationAbi,
+        args: [EXECUTION_MODE_OP_DATA, encodeCalls(parameters.calls, opData)],
+        functionName: 'simulateExecute'
+      });
+
+      const stateOverride: StateOverride = [
+        {
+          address: owner.address,
+          code: simulationBytecode
+        }
+      ];
+
+      const [estimatedGas, estimatedL1Fee, deployed] = await Promise.all([
+        estimateGas(client, {
+          blockTag: 'pending',
+          data,
+          stateOverride,
+          to: owner.address
+        }),
+        estimateL1Fee(client, owner.address, data),
+        isDeployed()
+      ]);
+
+      return {
+        estimatedGas: estimatedGas + delegationGas(deployed ? 0 : 1),
+        estimatedL1Fee
+      };
+    },
+    getAddress: async () => owner.address,
+    getFactoryArgs: async () => ({
+      factory: '0x7702',
+      factoryData: '0x'
+    }),
+    getNonce,
+    getStubSignature: async () => STUB_SIGNATURE,
+    isDeployed,
+    signAuthorization: () =>
+      viem_signAuthorization(client, {
+        account: owner,
+        address: GELATO_DELEGATION_ADDRESS,
+        chainId: client.chain.id
+      }),
+    signMessage: (parameters) =>
+      signMessage(client, {
+        account: owner,
+        message: parameters.message
+      }),
+    signTypedData: (parameters) =>
+      signTypedData(client, {
+        ...(parameters as TypedDataDefinition),
+        account: owner
+      }),
+    signUserOperation: async (parameters) => {
+      const typedData = getUserOperationTypedData({
+        chainId: client.chain.id,
+        entryPointAddress: entryPoint08Address,
+        userOperation: {
+          ...parameters,
+          sender: parameters.sender ?? owner.address
+        }
+      });
+
+      return signTypedData(client, {
+        ...typedData,
+        account: owner
+      });
+    },
+    type: 'smart'
+  };
+};

package/account/adapters/index.ts

@@ -0,0 +1 @@
+export * from './gelato/index.js';

package/account/adapters/types/index.ts

@@ -0,0 +1,36 @@
+import type { Abi, Call, Chain, Hex, SignedAuthorization } from 'viem';
+import type { EntryPointVersion, SmartAccountImplementation } from 'viem/account-abstraction';
+
+export type EstimateParameters = {
+  calls: Call[];
+};
+
+export type EstimateReturnType = {
+  estimatedGas: bigint;
+  estimatedL1Fee?: bigint;
+};
+
+export type EncodeCallDataParameters = EstimateParameters & {
+  nonce: bigint;
+};
+
+export type GelatoSmartAccountExtension = {
+  chain: Chain;
+};
+
+export type GelatoSmartAccountActions = {
+  estimate: (parameters: EstimateParameters) => Promise<EstimateReturnType>;
+  encodeCallData: (parameters: EncodeCallDataParameters) => Promise<Hex>;
+  signAuthorization: () => Promise<SignedAuthorization>;
+};
+
+export type GelatoSmartAccountImplementation<
+  entryPointAbi extends Abi | readonly unknown[] = Abi,
+  entryPointVersion extends EntryPointVersion = EntryPointVersion
+> = SmartAccountImplementation<
+  entryPointAbi,
+  entryPointVersion,
+  GelatoSmartAccountExtension,
+  true
+> &
+  GelatoSmartAccountActions;

package/account/index.ts

@@ -0,0 +1,60 @@
+import type { Hex } from 'viem';
+import type { SmartAccount } from 'viem/account-abstraction';
+import {
+  createGelatoEvmRelayerClient,
+  type FeeQuote,
+  type GelatoEvmRelayerClient,
+  type TerminalStatus
+} from '../relayer/index.js';
+import {
+  type GetFeeQuoteParameters,
+  getFeeQuote,
+  type SendTransactionParameters,
+  type SendTransactionSyncParameters,
+  sendTransaction,
+  sendTransactionSync
+} from './actions/index.js';
+import type { GelatoSmartAccountImplementation } from './adapters/types/index.js';
+
+export * from './adapters/index.js';
+
+export type GelatoSmartAccountClient = Pick<
+  GelatoEvmRelayerClient,
+  'getCapabilities' | 'getStatus' | 'waitForStatus'
+> & {
+  sendTransaction: (parameters: SendTransactionParameters) => Promise<Hex>;
+  sendTransactionSync: (parameters: SendTransactionSyncParameters) => Promise<TerminalStatus>;
+  getFeeQuote: (parameters: GetFeeQuoteParameters) => Promise<FeeQuote>;
+};
+
+export type GelatoSmartAccountClientConfig = {
+  apiKey: string;
+  account: SmartAccount<GelatoSmartAccountImplementation>;
+};
+
+export const createGelatoSmartAccountClient = async (
+  parameters: GelatoSmartAccountClientConfig
+): Promise<GelatoSmartAccountClient> => {
+  const { account, apiKey } = parameters;
+
+  const client = createGelatoEvmRelayerClient({
+    apiKey,
+    testnet: account.chain.testnet ?? false
+  });
+
+  const capabilities = (await client.getCapabilities())[account.chain.id];
+
+  if (!capabilities) {
+    throw new Error(`Chain not supported: ${account.chain.id}`);
+  }
+
+  return {
+    getCapabilities: () => client.getCapabilities(),
+    getFeeQuote: (parameters) => getFeeQuote(client, account, capabilities, parameters),
+    getStatus: (parameters) => client.getStatus(parameters),
+    sendTransaction: (parameters) => sendTransaction(client, account, capabilities, parameters),
+    sendTransactionSync: (parameters) =>
+      sendTransactionSync(client, account, capabilities, parameters),
+    waitForStatus: (parameters) => client.waitForStatus(parameters)
+  };
+};

package/account/utils/delegation.ts

@@ -0,0 +1,9 @@
+import { type Address, concatHex, type Hex } from 'viem';
+
+const DELEGATION_GAS = 25_000n;
+
+export const delegationGas = (authorizationCount: number): bigint => {
+  return DELEGATION_GAS * BigInt(authorizationCount);
+};
+
+export const delegationCode = (address: Address): Hex => concatHex(['0xef0100', address]);

package/account/utils/estimation.ts

@@ -0,0 +1,29 @@
+import {
+  type Address,
+  type Chain,
+  type ChainContract,
+  type Client,
+  type Hex,
+  type Transport,
+  zeroAddress
+} from 'viem';
+import { estimateL1Fee as viem_estimateL1Fee } from 'viem/op-stack';
+
+export const estimateL1Fee = async (
+  client: Client<Transport, Chain>,
+  to: Address,
+  data: Hex
+): Promise<bigint | undefined> => {
+  const gasPriceOracle = client.chain.contracts?.['gasPriceOracle'] as ChainContract | undefined;
+
+  if (!gasPriceOracle) {
+    return undefined;
+  }
+
+  return await viem_estimateL1Fee(client, {
+    account: zeroAddress,
+    data,
+    gasPriceOracleAddress: gasPriceOracle.address,
+    to
+  });
+};

package/account/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './delegation.js';
+export * from './estimation.js';

package/bundler/actions/estimateUserOperationGas.ts

@@ -0,0 +1,63 @@
+import type { BaseError, Chain, Client, Transport } from 'viem';
+import {
+  type EstimateUserOperationGasParameters,
+  type EstimateUserOperationGasReturnType,
+  formatUserOperationGas,
+  formatUserOperationRequest,
+  getUserOperationError,
+  type PrepareUserOperationParameters,
+  type SmartAccount,
+  type UserOperation
+} from 'viem/account-abstraction';
+import { parseAccount } from 'viem/accounts';
+import type { CapabilitiesByChain } from '../../relayer/evm/actions/index.js';
+import { AccountNotFoundError, type Payment } from '../../types/index.js';
+import { serializeStateOverride } from '../../utils/index.js';
+import { prepareUserOperation } from './prepareUserOperation.js';
+
+export const estimateUserOperationGas = async <account extends SmartAccount | undefined>(
+  client: Client<Transport, Chain | undefined, account>,
+  parameters: EstimateUserOperationGasParameters,
+  capabilities: CapabilitiesByChain,
+  payment?: Payment
+): Promise<EstimateUserOperationGasReturnType> => {
+  const { account: account_ = client.account, entryPointAddress, stateOverride } = parameters;
+
+  if (!account_ && !parameters.sender) throw new AccountNotFoundError();
+  const account = account_ ? parseAccount(account_) : undefined;
+
+  const rpcStateOverride = serializeStateOverride(stateOverride);
+
+  const request = account
+    ? await prepareUserOperation(
+        client,
+        {
+          ...parameters,
+          parameters: ['authorization', 'factory', 'nonce', 'paymaster', 'signature']
+        } as unknown as PrepareUserOperationParameters,
+        capabilities,
+        payment
+      )
+    : parameters;
+
+  try {
+    const params = [
+      formatUserOperationRequest(request as UserOperation),
+      // biome-ignore lint/style/noNonNullAssertion: copied from viem
+      (entryPointAddress ?? account?.entryPoint?.address)!
+    ] as const;
+
+    const result = await client.request({
+      method: 'eth_estimateUserOperationGas',
+      params: rpcStateOverride ? [...params, rpcStateOverride] : [...params]
+    });
+    return formatUserOperationGas(result) as EstimateUserOperationGasReturnType<account>;
+  } catch (error) {
+    // biome-ignore lint/suspicious/noExplicitAny: copied from viem
+    const calls = (parameters as any).calls;
+    throw getUserOperationError(error as BaseError, {
+      ...(request as UserOperation),
+      ...(calls ? { calls } : {})
+    });
+  }
+};

package/bundler/actions/getUserOperationGasPrice.ts

@@ -0,0 +1,25 @@
+import type { Client, EstimateFeesPerGasReturnType } from 'viem';
+import type { Payment } from '../../types/index.js';
+
+export type GetUserOperationGasPriceReturnType = EstimateFeesPerGasReturnType<'eip1559'>;
+
+export const getUserOperationGasPrice = async (
+  client: Client,
+  payment?: Payment
+): Promise<GetUserOperationGasPriceReturnType> => {
+  if (payment) {
+    return {
+      maxFeePerGas: 0n,
+      maxPriorityFeePerGas: 0n
+    };
+  }
+
+  const { maxFeePerGas, maxPriorityFeePerGas } = await client.request({
+    method: 'gelato_getUserOperationGasPrice'
+  } as never);
+
+  return {
+    maxFeePerGas: BigInt(maxFeePerGas),
+    maxPriorityFeePerGas: BigInt(maxPriorityFeePerGas)
+  };
+};

package/bundler/actions/getUserOperationQuote.ts

@@ -0,0 +1,83 @@
+import type { BaseError, Client, Transport } from 'viem';
+import {
+  type EstimateUserOperationGasParameters,
+  type EstimateUserOperationGasReturnType,
+  formatUserOperationRequest,
+  getUserOperationError,
+  type PrepareUserOperationParameters,
+  type SmartAccount,
+  type UserOperation
+} from 'viem/account-abstraction';
+import { parseAccount } from 'viem/accounts';
+import type { Chain } from 'viem/chains';
+import type { CapabilitiesByChain } from '../../relayer/evm/actions/index.js';
+import { AccountNotFoundError, type Payment } from '../../types/index.js';
+import { serializeStateOverride } from '../../utils/index.js';
+import { prepareUserOperation } from './prepareUserOperation.js';
+
+export type GetUserOperationQuoteParameters = Omit<
+  EstimateUserOperationGasParameters,
+  'paymaster' | 'paymasterContext'
+>;
+
+export type GetUserOperationQuoteReturnType = EstimateUserOperationGasReturnType & {
+  fee: bigint;
+  gas: bigint;
+  l1Fee?: bigint;
+};
+
+export const getUserOperationQuote = async <account extends SmartAccount | undefined>(
+  client: Client<Transport, Chain | undefined, account>,
+  parameters: GetUserOperationQuoteParameters,
+  capabilities: CapabilitiesByChain,
+  payment?: Payment
+): Promise<GetUserOperationQuoteReturnType> => {
+  const { account: account_ = client.account, entryPointAddress, stateOverride } = parameters;
+
+  if (!account_ && !parameters.sender) throw new AccountNotFoundError();
+  const account = account_ ? parseAccount(account_) : undefined;
+
+  const rpcStateOverride = serializeStateOverride(stateOverride);
+
+  const request = account
+    ? await prepareUserOperation(
+        client,
+        {
+          ...parameters,
+          parameters: ['authorization', 'factory', 'nonce', 'signature']
+        } as unknown as PrepareUserOperationParameters,
+        capabilities,
+        payment
+      )
+    : parameters;
+
+  try {
+    const params = [
+      formatUserOperationRequest(request as UserOperation),
+      // biome-ignore lint/style/noNonNullAssertion: copied from viem
+      (entryPointAddress ?? account?.entryPoint?.address)!
+    ] as const;
+
+    const { fee, gas, l1Fee, preVerificationGas, verificationGasLimit, callGasLimit } =
+      await client.request({
+        method: 'gelato_getUserOperationQuote',
+        params: rpcStateOverride ? [...params, rpcStateOverride] : [...params]
+      } as never);
+
+    return {
+      callGasLimit: BigInt(callGasLimit),
+      fee: BigInt(fee),
+      gas: BigInt(gas),
+      l1Fee: l1Fee ? BigInt(l1Fee) : undefined,
+      preVerificationGas: BigInt(preVerificationGas),
+      verificationGasLimit: BigInt(verificationGasLimit)
+    };
+  } catch (error) {
+    // biome-ignore lint/suspicious/noExplicitAny: copied from viem
+    const calls = (parameters as any).calls;
+    throw getUserOperationError(error as BaseError, {
+      ...(request as UserOperation),
+      ...(calls ? { calls } : {})
+    });
+  }
+};

package/bundler/actions/index.ts

@@ -0,0 +1,6 @@
+export * from './estimateUserOperationGas.js';
+export * from './getUserOperationGasPrice.js';
+export * from './getUserOperationQuote.js';
+export * from './prepareUserOperation.js';
+export * from './sendUserOperation.js';
+export * from './sendUserOperationSync.js';