Dual Interaction Layers

NMT supports two distinct ways for users to interact with DeFi protocols. Understanding which path a transaction takes is critical for working on any transaction-related code.

A deposit into Yearn on Base. The NMT modal (left) prepares the transaction; the wallet extension (right) shows the token approval for the user to sign.

The Two Modes

MODE 1: Delegate + Safe                    MODE 2: EOA (Direct Wallet)
========================                    ===========================

User's Wallet (EOA)                         User's Wallet (EOA)
       |                                           |
       | signs EIP-712 message                     | signs transaction directly
       v                                           v
DelegateBundler                             Blockchain (direct call)
       |
       | validates permissions
       v
Protocol Module (e.g. AaveModule)
       |
       | executes via Safe
       v
Gnosis Safe (holds funds)
       |
       v
Blockchain

Mode 1: Delegate + Safe

The user's funds live in a Gnosis Safe (smart wallet). A delegate executes DeFi strategies on their behalf, within the bounds of granted permissions.

Use case: Asset managers controlling client wallets. Advisors executing strategies for advisees. Institutional delegation.

Mode 2: EOA (Direct Wallet)

The user trades directly from their own wallet. No Safe, no delegation, no permission checks.

Use case: Personal trading. Users who want direct control without delegation overhead.

How the Code Branches

Throughout the frontend, the isSafe prop controls which execution path is taken. Every transaction component accepts it:

// Pattern used across all protocol components
export const AaveBalancesTable = ({
  address,
  isSafe = false,  // defaults to EOA mode
}: {
  address: string | null;
  isSafe?: boolean;
}) => {
  // ...

  const withdrawSelected = async () => {
    if (isSafe) {
      await withdrawFromSafe(positions, amounts);  // Bundler path
    } else {
      await withdrawEOA(position, amount);          // Direct path
    }
  };
};

Components that branch on isSafe:

Safe Path: Step by Step

When isSafe = true, a withdrawal from Aave looks like this:

1. PREPARE    — Build call array (approve + withdraw calls)
                via buildAaveWithdrawCall()

2. SIGN       — Delegate signs EIP-712 typed data:
                { callsDataHash, nonce, deadline }

3. SIMULATE   — DelegateBundler.simulateExecuteAndRevert()
                to catch errors before spending gas

4. RELAY      — Submit to Gelato Relay for sponsored execution
                (platform pays gas, not the user)

5. CONFIRM    — Poll Gelato for task status until confirmed

Key files:

• Bundler service: features/delegations/services/bundler/service.ts
• Relay service: features/delegations/services/relay-swap-service.ts

EOA Path: Step by Step

When isSafe = false, the same withdrawal looks like this:

1. PREPARE    — Encode the withdraw transaction calldata

2. SIGN+SEND  — walletClient.sendTransaction({
                  to: aavePoolAddress,
                  data: withdrawCalldata
                })

3. CONFIRM    — publicClient.waitForTransactionReceipt()

Key file: v2/transactions/swaps/hooks/use-execute-swap.ts

Token Swaps: Mode Differences

Token swaps have additional complexity because different swap providers have different Safe compatibility:

Why Cow Protocol is Safe-Only

Cow Protocol uses a PRESIGN signing scheme — the order is pre-signed on-chain through the Safe module rather than signed off-chain by an EOA. This enables MEV protection but requires the Safe infrastructure:

// Cow Swap always uses PRESIGN for Safe execution
const advancedSettings = {
  quoteRequest: {
    signingScheme: SigningScheme.PRESIGN,
    receiver: safeAddress,
  },
};

The Cow Swap module builds calls that go through the DelegateBundler:

• buildCowSwapApprovalCall() — approve token spending
• buildCowSwapSignOrderCall() — pre-sign the order on-chain

Decision Matrix