customizeBatch

customizeBatch(customizations: CustomizationConfig[]): Promise<CustomizeBatchResponse>

interface CustomizationConfig {
  /** Protocol UUID */
  protocolId: string;

  /** Array of pool names to use (empty array when autoselect is true) */
  pools: string[];

  /** Chain ID (8453 for Base, 42161 for Arbitrum, 1 for Ethereum Mainnet) */
  chainId: number;

  /** Enable automatic pool selection by the rebalance engine */
  autoselect: boolean;
}

interface CustomizeBatchResponse {
  success: boolean;
}

const userDetails = await sdk.getUserDetails();

// Access configured protocols with their IDs
userDetails.protocols?.forEach((protocol) => {
  console.log(`${protocol}: ${protocol}`);
});

const protocolsResponse = await sdk.getAvailableProtocols(8453);

// Get all available protocols for a chain
protocolsResponse.protocols.forEach((protocol) => {
  console.log(`${protocol.name}: ${protocol.id}`);
});

getAvailablePools(protocolId: string, strategy?: "conservative" | "aggressive"): Promise<GetPoolsResponse>

getSelectedPools(protocolId: string, chainId: number): Promise<GetSelectedPoolsResponse>

await sdk.connectAccount(privateKey, chainId);

// Get user details to find protocol IDs
const userDetails = await sdk.getUserDetails();
const morphoProtocolId = userDetails.protocols?.find(
  id => id.includes("morpho")
);

if (morphoProtocolId) {
  // Get available pools for Morpho
  const pools = await sdk.getAvailablePools(morphoProtocolId);
  console.log("Available pools:", pools.pools);

  // Configure specific pools for Morpho on Base
  await sdk.customizeBatch([
    {
      protocolId: morphoProtocolId,
      pools: ["Gauntlet USDC Core", "Steakhouse USDC"],
      chainId: 8453,  // Base
      autoselect: false
    }
  ]);

  console.log("Morpho configured with specific pools on Base");
}

// Configure the same protocol across multiple chains
const aaveProtocolId = userDetails.protocols?.find(
  id => id.includes("aave")
);

if (aaveProtocolId) {
  await sdk.customizeBatch([
    {
      protocolId: aaveProtocolId,
      pools: ["USDC"],
      chainId: 8453,  // Base - specific pool
      autoselect: false
    },
    {
      protocolId: aaveProtocolId,
      pools: [],
      chainId: 42161,  // Arbitrum - autoselect
      autoselect: true
    },
    {
      protocolId: aaveProtocol.id,
      pools: [],
      chainId: 1,  // Ethereum Mainnet - autoselect
      autoselect: true
    }
  ]);

  console.log("Aave configured across 3 chains");
}

// Configure multiple protocols at once using getAvailableProtocols
const protocolsResponse = await sdk.getAvailableProtocols(8453);
const customizations = [];

for (const protocol of protocolsResponse.protocols) {
  // Get available pools
  const poolsResponse = await sdk.getAvailablePools(protocol.id);

  // Select first 2 pools or use autoselect
  if (poolsResponse.pools.length > 0) {
    customizations.push({
      protocolId: protocol.id,
      pools: poolsResponse.pools.slice(0, 2),
      chainId: 8453,
      autoselect: false
    });
  } else {
    customizations.push({
      protocolId: protocol.id,
      pools: [],
      chainId: 8453,
      autoselect: true
    });
  }
}

// Apply all customizations at once
await sdk.customizeBatch(customizations);
console.log(`Configured ${customizations.length} protocols`);

// Enable autoselect for a protocol (let engine choose best pools)
await sdk.customizeBatch([
  {
    protocolId: "protocol-uuid",
    pools: [],  // Empty array when autoselect is true
    chainId: 8453,
    autoselect: true  // Engine will automatically select best pools
  }
]);

// After configuration, verify the settings
const selectedPools = await sdk.getSelectedPools(
  morphoProtocol.id,
  8453
);

console.log("Currently configured:");
console.log("- Autoselect:", selectedPools.autoselect);
console.log("- Pools:", selectedPools.pools);

// Get user details to see all customizations
const userDetails = await sdk.getUserDetails();

// The customization field shows all configured pools per protocol per chain
console.log("Customizations:", userDetails.customization);

// Structure:
// {
//   "protocolId": {
//     "chainId": {
//       "pools": ["pool1", "pool2"],
//       "autoselect": false
//     }
//   }
// }

// Get available pools for Morpho
const pools = await sdk.getAvailablePools("morpho-uuid");

// Select pools with highest APY (you'd get APY data separately)
const highApyPools = ["Gauntlet USDC Prime", "Steakhouse High Yield USDC"];

await sdk.customizeBatch([
  {
    protocolId: "morpho-uuid",
    pools: highApyPools,
    chainId: 8453,
    autoselect: false
  }
]);

// Conservative: Use only verified, low-risk pools
await sdk.customizeBatch([
  {
    protocolId: "aave-uuid",
    pools: ["USDC"],  // Stablecoin only
    chainId: 8453,
    autoselect: false
  }
]);

// Aggressive: Let engine optimize across all pools
await sdk.customizeBatch([
  {
    protocolId: "morpho-uuid",
    pools: [],
    chainId: 8453,
    autoselect: true  // Engine will chase highest yields
  }
]);

// Different strategies per chain based on liquidity/APY
await sdk.customizeBatch([
  {
    protocolId: "euler-uuid",
    pools: ["Euler Earn USDC", "Euler Arbitrum Yield"],
    chainId: 42161,  // Arbitrum - specific pools
    autoselect: false
  },
  {
    protocolId: "euler-uuid",
    pools: [],
    chainId: 8453,  // Base - autoselect (less liquidity)
    autoselect: true
  }
]);

// Periodically update based on market conditions
async function rebalanceStrategy() {
  const protocolsResponse = await sdk.getAvailableProtocols(8453);

  for (const protocol of protocolsResponse.protocols) {
    // Get latest pools and their performance
    const pools = await sdk.getAvailablePools(protocol.id);

    // Apply your selection logic
    const selectedPools = selectBestPools(pools.pools); // Your logic

    await sdk.customizeBatch([{
      protocolId: protocol.id,
      pools: selectedPools,
      chainId: 8453,
      autoselect: false
    }]);
  }
}

// Run daily or based on APY changes
setInterval(rebalanceStrategy, 24 * 60 * 60 * 1000);