Sudo Policy

The Sudo Policy grants unrestricted access to specified contract functions. It’s the simplest policy—and the most powerful.

When to Use Sudo

Target contract is audited and trusted (Uniswap, Aave, Morpho)

No user funds at direct risk (game actions, governance votes)

You need simplicity over granular control

Combined with time limits or usage limits

When NOT to Use Sudo

Agent handles significant user funds without other limits

Target contract has dangerous functions (e.g., approve for arbitrary spenders)

You need spending caps or parameter validation

Indefinite access without time bounds

Basic Usage

const actions = mcNexus.buildSessionAction({
  type: 'transfer',
  data: {
    chainIds: [10],
    contractAddress: UNISWAP_ROUTER,
    policies: [{ type: "sudo" }]
  }
})

Agent Examples

Yield Optimizer Agent

Trust deposits/withdrawals on vetted protocols:

const TRUSTED_PROTOCOLS = {
  morpho: "0xA2Cac0023a4797b4729Db94783405189a4203AFc",
  aave: "0x...",
};

const now = Math.floor(Date.now() / 1000)
const validAfter = now
const validUntil = now + 3600

const timeframePolicy = mcNexus.buildActionPolicy({
  type: "timeframe",
  validAfter, // unix-timestamp when policy becomes active
  validUntil  // unix-timestamp when policy expires
});

// Morpho deposit
const [actionOne] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [10],
    contractAddress: TRUSTED_PROTOCOLS.morpho,
    functionSignature: toFunctionSelector("deposit(uint256,address)"),
    policies: [timeframePolicy]
  }
})

// Morpho withdraw
const [actionTwo] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [10],
    contractAddress: TRUSTED_PROTOCOLS.morpho,
    functionSignature: toFunctionSelector("withdraw(uint256,address,address)"),
    policies: [timeframePolicy]
  }
})

// Aave supply
const [actionThree] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [10],
    contractAddress: TRUSTED_PROTOCOLS.aave,
    functionSignature: toFunctionSelector("supply(address,uint256,address,uint16)"),
    policies: [timeframePolicy]
  }
})

// Aave withdraw
const [actionFour] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [10],
    contractAddress: TRUSTED_PROTOCOLS.aave,
    functionSignature: toFunctionSelector("withdraw(address,uint256,address)"),
    policies: [timeframePolicy]
  }
})

const quote = await meeClient.getSessionQuote({
  mode: "PREPARE",
  enableSession: {
    redeemer: agentSigner.address,
    actions: [actionOne, actionTwo, actionThree, actionFour],
    // Cap gas spend
    maxPaymentAmount: parseUnits("50", 6),
  },
  simulation: { simulate: true },
  feeToken: { address: USDC, chainId: 8453 },
  // Fund SCA
  trigger: {
    tokenAddress: USDC,
    chainId: 8453,
    amount: parseUnits("2", 6),
  },
  // Any additional Instructions
  instructions: [...]
});

// Store the sessions details for later use.
let sessionDetails: SessionDetail[] = [];

if (quote) {
  const { hash } = await meeClient.executeSessionQuote(quote);
  await meeClient.waitForSupertransactionReceipt({ hash });

  if (quote.sessionDetails) sessionDetails = quote.sessionDetails;
}

Gaming Agent

Full access to game contract with usage limits:

const GAME_CONTRACT = "0x...";

const [claimAction] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [8453],
    contractAddress: GAME_CONTRACT,
    functionSignature: toFunctionSelector("claimRewards()"),
    policies: [
      {
        type: "usageLimit",
        limit: 100n // Max 100 claims
      }
    ]
  }
})

const [performAction] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [8453],
    contractAddress: GAME_CONTRACT,
    functionSignature: toFunctionSelector("performAction(uint256)"),
    policies: [
      {
        type: "usageLimit",
        limit: 1000n // Max 1000 actions
      }
    ]
  }
})

Governance Agent

Vote on proposals automatically:

const GOVERNOR = "0x...";

const [castVoteAction] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [8453],
    contractAddress: GOVERNOR,
    functionSignature: toFunctionSelector("castVote(uint256,uint8)"),
    policies: [
      // 1 year for governance
      {
        type: "timeframe",
        validAfter: Math.floor(Date.now() / 1000),
        validUntil: Math.floor(Date.now() / 1000) + 365 * 24 * 60 * 60
      }
    ]
  }
})

Security Checklist

Timeframe Policy configured

Only specific functions allowed (not entire contract)

Target contract is audited

Usage limit considered for high-risk actions

Gas spend capped (maxPaymentAmount)

Common Mistakes

Granting Sudo to approve() functionThis lets the agent approve arbitrary spenders. Never do this:

// ❌ DANGEROUS
functionSignature: toFunctionSelector("approve(address,uint256)")

No time limitWithout timeframe policy, the permission never expires:

// ❌ BAD - no time limit
const actions = mcNexus.buildSessionAction({
  type: 'transfer',
  data: {
    chainIds: [10],
    contractAddress: UNISWAP_ROUTER,
    policies: [{ type: "sudo" }]
  }
})

// ✅ GOOD - expires in 30 days
const now = Math.floor(Date.now() / 1000)
const validAfter = now
const validUntil = now + 30 * 24 * 60 * 60

const actions = mcNexus.buildSessionAction({
  type: 'transfer',
  data: {
    chainIds: [10],
    contractAddress: UNISWAP_ROUTER,
    policies: [
      { type: "sudo" },
      {
        type: "timeframe",
        validAfter,
        validUntil
      }
    ]
  }
})

When to Upgrade to Universal Action

Switch to Universal Action when you need:

Spending limits (per-action or total)
Recipient whitelisting
Parameter validation
Cumulative caps

See Universal Action Policy for details.

Build Your Agent

Session Policies

When to Use Sudo

When NOT to Use Sudo

Basic Usage

Agent Examples

Yield Optimizer Agent

Gaming Agent

Governance Agent

Security Checklist

Common Mistakes

When to Upgrade to Universal Action

​When to Use Sudo

​When NOT to Use Sudo

​Basic Usage

​Agent Examples

​Yield Optimizer Agent

​Gaming Agent

​Governance Agent

​Security Checklist

​Common Mistakes

​When to Upgrade to Universal Action

When to Use Sudo

When NOT to Use Sudo

Basic Usage

Agent Examples

Yield Optimizer Agent

Gaming Agent

Governance Agent

Security Checklist

Common Mistakes

When to Upgrade to Universal Action