Agent Types & Examples

const UNISWAP_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481";  // Base
const USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";

const now = Math.floor(Date.now() / 1000)
const validAfter = now
const validUntil = now + 7 * 24 * 60 * 60

// 7-day access window
const timeframePolicy = mcNexus.buildActionPolicy({
  type: "timeframe",
  validAfter,
  validUntil
});

const universalPolicy = mcNexus.buildActionPolicy({
  type: "universal",
  rules: [
    // Recipient must be user's account (prevent draining)
    {
      condition: "equal",
      calldataOffset: calldataArgument(4),
      comparisonValue: userAccountAddress
    },
    // Max 500 USDC per trade, 5000 Max limit
    {
      condition: "lessThanOrEqual",
      calldataOffset: calldataArgument(5),
      comparisonValue: parseUnits("500", 6),
      isLimited: true,
      usage: { limit: parseUnits("5000", 6), used: 0n }
    }
  ],
});

const actions = mcNexus.buildSessionAction({
  type: "custom",
  data: {
    chainIds: [8453],
    contractAddress: UNISWAP_ROUTER,
    functionSignature: toFunctionSelector("exactInputSingle((address,address,uint24,address,uint256,uint256,uint160))"),
    policies: [universalPolicy, timeframePolicy]
  }
});

const quote = await meeClient.getSessionQuote({
  mode: "PREPARE",
  enableSession: {
    redeemer: sessionSigner.address,
    actions,
    // Max gas spend
    maxPaymentAmount: parseUnits("50", 6),
  },
  simulation: { simulate: true },
  feeToken: { address: USDC, chainId: 8453 },
  trigger: {
    tokenAddress: USDC,
    chainId: 8453,
    amount: parseUnits("2", 6),
  },
});

// 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;
}

async function executeTrade(signal: TradeSignal) {
  if (signal.confidence < 0.7) return;  // Only high-confidence trades
  
  const instructions = await agentAccount.buildComposable({
    type: "default",
    data: {
      chainId: base.id,
      to: UNISWAP_ROUTER,
      abi: UniswapAbi,
      functionName: "exactInputSingle",
      args: [{
        tokenIn: signal.fromToken,
        tokenOut: signal.toToken,
        fee: 3000,
        recipient: userAccountAddress,
        amountIn: signal.amount,
        amountOutMinimum: signal.minOutput,
        sqrtPriceLimitX96: 0n
      }]
    }
  });
  
  const quote = await agentClient.getSessionQuote({
    mode: "USE",
    sessionDetails,
    simulation: { simulate: true },
    feeToken: { address: USDC, chainId: 8453 },
    instructions
  });

  const { hash } = await agentClient.executeSessionQuote(quote);

  await agentClient.waitForSupertransactionReceipt({ hash });
}

const PROTOCOLS = {
  base: {
    morpho: "0xA2Cac0023a4797b4729Db94783405189a4203AFc",
    aave: "0x...",
  },
  optimism: {
    aave: "0x...",
    exactly: "0x...",
  }
};

const now = Math.floor(Date.now() / 1000)
const validAfter = now
const validUntil = now + 30 * 24 * 60 * 60

// 30-day access
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: [8453],
    contractAddress: PROTOCOLS.base.morpho,
    functionSignature: toFunctionSelector("deposit(uint256,address)"),
    policies: [timeframePolicy]
  }
})

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

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

// Aave withdraw
const [actionFour] = mcNexus.buildSessionAction({
  type: 'custom',
  data: {
    chainIds: [10],
    contractAddress: PROTOCOLS.optimism.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],
    // Generous gas for cross-chain
    maxPaymentAmount: parseUnits("100", 6),
  },
  simulation: { simulate: true },
  feeToken: { address: USDC, chainId: 8453 },
  // 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;
}

// Chargeable on day one of the month
const dayOneTimeframePolicy = mcNexus.buildActionPolicy({
  type: "timeframe",
  validAfter: ..., // unix-timestamp Eg: 1-1-2026 00:00:00 in unix timestamp
  validUntil: ...  // unix-timestamp Eg: 1-1-2026 23:59:59 in unix timestamp
});

// Used only once per month
const usagePolicy = mcNexus.buildActionPolicy({
  type: "usageLimit",
  limit: 1n
});

// Only specific recipient and specific amount
const paymentPolicy = mcNexus.buildActionPolicy({
  type: "universal",
  rules: [
    // Only send to merchant
    {
      condition: "equal",
      calldataOffset: calldataArgument(1),
      comparisonValue: MERCHANT
    },
    // Max 100 USDC per payment
    {
      condition: "lessThanOrEqual",
      calldataOffset: calldataArgument(2),
      comparisonValue: parseUnits("100", 6),
    }
  ],
  // Configure spending limit for native token
  valueLimitPerUse: 0n,
});

const monthOnePaymentAction = mcNexus.buildSessionAction({
  type: "transfer",
  data: {
    chainIds: [8453, 10],
    contractAddress: USDC,
    policies: [dayOneTimeframePolicy, usagePolicy, paymentPolicy]
  }
});

// 10 similar actions for 10 months

const monthTwelvePaymentAction = mcNexus.buildSessionAction({
  type: "transfer",
  data: {
    chainIds: [8453, 10],
    contractAddress: USDC,
    policies: [dayOneTimeframePolicy, usagePolicy, paymentPolicy]
  }
});

// 12 actions which can be executed only once per month on day one for a year.
// Get a session quote and execute it to enable a permission for subscriptions

// Chargeable in every quarter
const quarterlyTimeframePolicy = mcNexus.buildActionPolicy({
  type: "timeframe",
  validAfter: ..., // unix-timestamp Eg: 1-1-2026 in unix timestamp
  validUntil: ...  // unix-timestamp Eg: 31-3-2026 in unix timestamp
});

// Used only once per quarter
const usagePolicy = mcNexus.buildActionPolicy({
  type: "usageLimit",
  limit: 1n
});

const quarterOneRebalanceAction = mcNexus.buildSessionAction({
  type: "custom",
  data: {
    chainIds: [8453, 10],
    contractAddress: REBALANCER,
    functionSignature: '0x...',
    policies: [quarterlyTimeframePolicy, usagePolicy]
  }
});

// 2 similar actions for 2 quarters

const quarterFourRebalanceAction = mcNexus.buildSessionAction({
  type: "custom",
  data: {
    chainIds: [8453, 10],
    contractAddress: REBALANCER,
    functionSignature: '0x...',
    policies: [quarterlyTimeframePolicy, usagePolicy]
  }
});

// 4 actions which can be executed only once per quarter for a year.
// Get a session quote and execute it to enable a permissions for rebalancer

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
      }
    ]
  }
})

// Get a session quote and execute it to enable a permissions for game agent executions.