write.asset_manager.merkl_operator

Instructions

Implementation Reference

• src/tools/write/asset-managers/merkl-operator.ts:10-63 (handler)

  Handler function registerMerklOperatorTool that registers the write.asset_manager.merkl_operator MCP tool. Validates chain_id and reward_recipient, encodes Merkl operator callback data using ABI encoding, and returns {asset_managers, statuses, datas} for set_asset_managers. Supports enable/disable via enabled param.

  export function registerMerklOperatorTool(
    server: McpServer,
    _chains: Record<ChainId, ChainConfig>,
  ) {
    server.registerTool(
      "write.asset_manager.merkl_operator",
      {
        annotations: {
          title: "Encode Merkl Operator Automation",
          readOnlyHint: true,
          destructiveHint: false,
          idempotentHint: true,
          openWorldHint: false,
        },
        description:
          "Encode args for the Merkl operator automation. Claims external Merkl protocol incentive rewards into the account — additional rewards paid by token teams on top of regular LP fees. Enable when the pool has active Merkl campaigns (check APY breakdown in read.strategy.list). Always combine with rebalancer when both are relevant — no conflict, extra free yield. Available on all supported chains. Returns { asset_managers, statuses, datas } — pass to write.account.set_asset_managers. Combinable with other intent tools.",
        outputSchema: IntentOutput,
        inputSchema: {
          reward_recipient: z.string().describe("Address to receive Merkl rewards"),
          enabled: z.boolean().default(true).describe("True to enable, false to disable"),
          chain_id: z.number().default(8453).describe(CHAIN_ID_DESCRIPTION),
        },
      },
      async (params) => {
        try {
          const validChainId = validateChainId(params.chain_id);
          const amAddress = getStandaloneAmAddress(validChainId, "merklOperator");
  
          if (!params.enabled)
            return formatResult(disabledIntent([amAddress], "Disable merkl_operator"));
  
          const validRewardRecipient = validateAddress(params.reward_recipient, "reward_recipient");
          const callbackData = encodeMerklOperatorCallbackData(MERKL_INITIATOR, validRewardRecipient);
  
          const result = {
            description: "Enable merkl_operator",
            asset_managers: [amAddress],
            statuses: [true],
            datas: [callbackData],
          };
          return formatResult(result);
        } catch (err) {
          return {
            content: [
              {
                type: "text" as const,
                text: `Error: ${err instanceof Error ? err.message : String(err)}`,
              },
            ],
            isError: true,
          };
        }
      },
    );

• src/tools/write/asset-managers/merkl-operator.ts:16-31 (schema)

  Input/output schema for the tool: requires reward_recipient (address string), enabled (boolean, default true), chain_id (number, default 8453). Output follows IntentOutput schema with asset_managers, statuses, datas arrays.

  {
    annotations: {
      title: "Encode Merkl Operator Automation",
      readOnlyHint: true,
      destructiveHint: false,
      idempotentHint: true,
      openWorldHint: false,
    },
    description:
      "Encode args for the Merkl operator automation. Claims external Merkl protocol incentive rewards into the account — additional rewards paid by token teams on top of regular LP fees. Enable when the pool has active Merkl campaigns (check APY breakdown in read.strategy.list). Always combine with rebalancer when both are relevant — no conflict, extra free yield. Available on all supported chains. Returns { asset_managers, statuses, datas } — pass to write.account.set_asset_managers. Combinable with other intent tools.",
    outputSchema: IntentOutput,
    inputSchema: {
      reward_recipient: z.string().describe("Address to receive Merkl rewards"),
      enabled: z.boolean().default(true).describe("True to enable, false to disable"),
      chain_id: z.number().default(8453).describe(CHAIN_ID_DESCRIPTION),
    },

• src/tools/index.ts:25-74 (registration)

  Tool registration entry point: registerMerklOperatorTool is called with (server, chains) in registerAllTools.

  import { registerSetAssetManagersTool } from "./write/asset-managers/set-asset-managers.js";
  import { registerSendTool } from "./dev/send.js";
  import { registerAddLiquidityTool } from "./write/account/add-liquidity.js";
  import { registerRemoveLiquidityTool } from "./write/account/remove-liquidity.js";
  import { registerSwapTool } from "./write/account/swap.js";
  import { registerDeleverageTool } from "./write/account/deleverage.js";
  import { registerStakeTool } from "./write/account/stake.js";
  import { registerCloseTool } from "./write/account/close.js";
  
  export function registerAllTools(
    server: McpServer,
    api: ArcadiaApiClient,
    chains: Record<ChainId, ChainConfig>,
  ) {
    // Read tools
    registerAccountTools(server, api, chains);
    registerPoolTools(server, api);
    registerAssetTools(server, api);
    registerStrategyTools(server, api);
    registerPointsTools(server, api);
    registerGuideTools(server);
    registerWalletTools(server, chains, api);
    registerAssetManagerTools(server);
  
    // Write tools — account
    registerCreateTool(server, chains);
    registerDepositTool(server, chains);
    registerWithdrawTool(server, chains);
    registerBorrowTool(server, chains, api);
    registerRepayTool(server, chains);
    registerAddLiquidityTool(server, api, chains);
    registerRemoveLiquidityTool(server, api);
    registerSwapTool(server, api);
    registerDeleverageTool(server, api);
    registerStakeTool(server, api);
    registerCloseTool(server, api, chains);
  
    // Write tools — wallet
    registerApproveTool(server, chains);
  
    // Write tools — pool (lending tranches, ERC-4626)
    registerPoolDepositTool(server, chains);
    registerPoolRedeemTool(server, chains);
  
    // Write tools — asset managers
    registerRebalancerTool(server, chains);
    registerCompounderTools(server, chains);
    registerYieldClaimerTools(server, chains);
    registerCowSwapperTool(server, chains);
    registerMerklOperatorTool(server, chains);

• src/tools/write/asset-managers/encoding.ts:176-189 (helper)

  encodeMerklOperatorCallbackData: ABI-encodes initiator address, rewardRecipient address, maxClaimFee, and empty metadata for the Merkl operator callback. Uses MERKL_INITIATOR address (0x521541D932B15631e8a1B037f17457C801722bA0).

  export function encodeMerklOperatorCallbackData(
    initiator: `0x${string}`,
    rewardRecipient: `0x${string}`,
  ): `0x${string}` {
    return encodeAbiParameters(
      [
        { name: "initiator", type: "address" },
        { name: "rewardRecipient", type: "address" },
        { name: "maxClaimFee", type: "uint256" },
        { name: "metaData_", type: "bytes" },
      ],
      [initiator, rewardRecipient, DEFAULT_MAX_CLAIM_FEE, "0x"],
    );
  }

• src/config/addresses.ts:276-289 (helper)

  getStandaloneAmAddress: resolves the standalone AM address for merklOperator (0x969F0251360b9Cf11c68f6Ce9587924c1B8b42C6) from the address book.

  export function getStandaloneAmAddress(chainId: ChainId, am: StandaloneAm): string {
    if (!CHAIN_STANDALONE_AMS[chainId].has(am)) {
      const supportedChains = (
        Object.entries(CHAIN_STANDALONE_AMS) as [string, ReadonlySet<StandaloneAm>][]
      )
        .filter(([, ams]) => ams.has(am))
        .map(([id]) => `${CHAIN_NAMES[Number(id) as ChainId]} (${id})`)
        .join(", ");
      throw new Error(
        `${STANDALONE_TO_USER_FACING[am]} is not available on ${CHAIN_NAMES[chainId]} (${chainId}). Supported chains: ${supportedChains}.`,
      );
    }
    return STANDALONE_AM_ADDRESSES[am];
  }