fix(agent-pendle): restore buy pt routing

Author: 0xTomDaniel

typescript/clients/web-ag-ui/apps/agent-pendle/src/core/pendleFunding.ts

@@ -1,21 +1,55 @@
 import type { WalletBalance } from '../clients/onchainActions.js';
 import type { FundingTokenOption } from '../workflow/context.js';
 
+type FundingTokenCandidate = FundingTokenOption & { valueUsd: number; chainId: string };
+
+const parseBalanceAmount = (amount: string): bigint => {
+  try {
+    return BigInt(amount);
+  } catch {
+    return 0n;
+  }
+};
+
+const choosePreferredCandidate = (
+  current: FundingTokenCandidate | undefined,
+  next: FundingTokenCandidate,
+): FundingTokenCandidate => {
+  if (!current) {
+    return next;
+  }
+  if (next.valueUsd !== current.valueUsd) {
+    return next.valueUsd > current.valueUsd ? next : current;
+  }
+  if (next.decimals !== current.decimals) {
+    return next.decimals > current.decimals ? next : current;
+  }
+  return parseBalanceAmount(next.balance) > parseBalanceAmount(current.balance) ? next : current;
+};
+
 export function buildFundingTokenOptions(params: {
   balances: readonly WalletBalance[];
   whitelistSymbols: readonly string[];
 }): FundingTokenOption[] {
   const whitelist = new Set(params.whitelistSymbols);
-  return params.balances
+  const dedupedCandidates = new Map<string, FundingTokenCandidate>();
+
+  for (const balance of params.balances
     .filter((balance) => Boolean(balance.symbol) && typeof balance.decimals === 'number')
     .filter((balance) => whitelist.has(balance.symbol ?? ''))
     .map((balance) => ({
+      chainId: balance.tokenUid.chainId,
       address: balance.tokenUid.address as `0x${string}`,
       symbol: balance.symbol ?? 'UNKNOWN',
       decimals: balance.decimals ?? 0,
       balance: balance.amount,
       valueUsd: balance.valueUsd ?? 0,
-    }))
+    }))) {
+    const key = `${balance.chainId}:${balance.address.toLowerCase()}`;
+    dedupedCandidates.set(key, choosePreferredCandidate(dedupedCandidates.get(key), balance));
+  }
+
+  return Array.from(dedupedCandidates.values())
     .sort((left, right) => {
       if (right.valueUsd !== left.valueUsd) {
         return right.valueUsd - left.valueUsd;
@@ -27,8 +61,9 @@ export function buildFundingTokenOptions(params: {
       return left.address.localeCompare(right.address);
     })
     .map((entry) => {
-      const { valueUsd, ...option } = entry;
+      const { valueUsd, chainId, ...option } = entry;
       void valueUsd;
+      void chainId;
       return option;
     });
 }

typescript/clients/web-ag-ui/apps/agent-pendle/src/core/pendleFunding.unit.test.ts

@@ -68,4 +68,36 @@ describe('buildFundingTokenOptions', () => {
     expect(options.map((option) => option.symbol)).toEqual(['USDC', 'USDC', 'USDT']);
     expect(options.map((option) => option.address)).toEqual(['0x0', '0x1', '0x2']);
   });
+
+  it('dedupes duplicate balances for the same token address', () => {
+    const balances: WalletBalance[] = [
+      balance({
+        address: '0x0b2b2b2076d95dda7817e785989fe353fe955ef9',
+        symbol: 'sUSDai',
+        decimals: 18,
+        amount: '49533087442598701335',
+        valueUsd: 49.53,
+      }),
+      balance({
+        address: '0x0b2b2b2076d95dda7817e785989fe353fe955ef9',
+        symbol: 'sUSDai',
+        decimals: 18,
+        amount: '49533087442598701335',
+        valueUsd: 49.53,
+      }),
+    ];
+
+    const options = buildFundingTokenOptions({
+      balances,
+      whitelistSymbols: ['sUSDai'],
+    });
+
+    expect(options).toHaveLength(1);
+    expect(options[0]).toMatchObject({
+      address: '0x0b2b2b2076d95dda7817e785989fe353fe955ef9',
+      symbol: 'sUSDai',
+      balance: '49533087442598701335',
+      decimals: 18,
+    });
+  });
 });

typescript/clients/web-ag-ui/apps/agent-pendle/src/workflow/execution.ts

@@ -656,7 +656,7 @@ export async function executeUnwind(params: {
 }
 
 export async function executeInitialDeposit(params: {
-  onchainActionsClient: Pick<OnchainActionsClient, 'createTokenizedYieldBuyPt'>;
+  onchainActionsClient: Pick<OnchainActionsClient, 'createSwap' | 'createTokenizedYieldBuyPt'>;
   txExecutionMode: PendleTxExecutionMode;
   clients?: OnchainClients;
   delegationBundle?: DelegationBundle;
@@ -665,17 +665,32 @@ export async function executeInitialDeposit(params: {
   targetMarket: TokenizedYieldMarket;
   fundingAmount: string;
 }): Promise<ExecutionResult> {
-  const fundingTokenUid = params.fundingToken.tokenUid;
   const transactions: TransactionPlan[] = [];
+  const targetUnderlyingTokenUid = params.targetMarket.underlyingToken.tokenUid;
+
+  let buyInputTokenUid = params.fundingToken.tokenUid;
+  let buyAmount = params.fundingAmount;
+
+  if (!isSameToken(buyInputTokenUid, targetUnderlyingTokenUid)) {
+    const swapPlan = await params.onchainActionsClient.createSwap({
+      walletAddress: params.walletAddress,
+      amount: params.fundingAmount,
+      amountType: 'exactIn',
+      fromTokenUid: buyInputTokenUid,
+      toTokenUid: targetUnderlyingTokenUid,
+      slippageTolerance: '0.01',
+    });
+
+    buyInputTokenUid = targetUnderlyingTokenUid;
+    buyAmount = swapPlan.exactToAmount;
+    transactions.push(...swapPlan.transactions);
+  }
 
-  // Buy PT using the selected funding token directly.
-  // Pendle can route from common stables (eg USDai) into PT markets even when the market underlying differs (eg sUSDai),
-  // so we avoid forcing a generic DEX swap to the underlying first.
   const buyPlan = await params.onchainActionsClient.createTokenizedYieldBuyPt({
     walletAddress: params.walletAddress,
     marketAddress: params.targetMarket.marketIdentifier.address,
-    inputTokenUid: fundingTokenUid,
-    amount: params.fundingAmount,
+    inputTokenUid: buyInputTokenUid,
+    amount: buyAmount,
     slippage: '0.01',
   });
 

typescript/clients/web-ag-ui/apps/agent-pendle/src/workflow/execution.unit.test.ts

@@ -714,6 +714,102 @@ describe('executeInitialDeposit', () => {
     executeTransactionMock.mockReset();
     redeemDelegationsAndExecuteTransactionsMock.mockReset();
   });
+  it('swaps to the target underlying before buying PT when the funding token differs', async () => {
+    const createSwap = vi.fn().mockResolvedValue({
+      exactFromAmount: '10000000',
+      exactToAmount: '9500000000000000000',
+      transactions: [
+        { type: 'EVM_TX', to: '0xswap', data: '0x03', value: '0', chainId: '42161' },
+      ],
+    });
+    const createTokenizedYieldBuyPt = vi.fn().mockResolvedValue({
+      transactions: [{ type: 'EVM_TX', to: '0xbuy', data: '0x04', value: '0', chainId: '42161' }],
+    });
+    const onchainActionsClient = {
+      createSwap,
+      createTokenizedYieldBuyPt,
+    } as unknown as Pick<OnchainActionsClient, 'createTokenizedYieldBuyPt'>;
+
+    executeTransactionMock
+      .mockResolvedValueOnce({ transactionHash: '0xswaphash' })
+      .mockResolvedValueOnce({ transactionHash: '0xbuyhash' });
+
+    const clients = {} as OnchainClients;
+
+    const fundingToken = {
+      tokenUid: { chainId: '42161', address: '0xsusdai' },
+      name: 'sUSDai',
+      symbol: 'sUSDai',
+      isNative: false,
+      decimals: 18,
+      iconUri: undefined,
+      isVetted: true,
+    };
+
+    const targetMarket: TokenizedYieldMarket = {
+      marketIdentifier: { chainId: '42161', address: '0xmarket-new' },
+      expiry: '2030-01-01',
+      details: {},
+      ptToken: {
+        tokenUid: { chainId: '42161', address: '0xpt-new' },
+        name: 'PT-NEW',
+        symbol: 'PT-NEW',
+        isNative: false,
+        decimals: 18,
+        iconUri: undefined,
+        isVetted: true,
+      },
+      ytToken: {
+        tokenUid: { chainId: '42161', address: '0xyt-new' },
+        name: 'YT-NEW',
+        symbol: 'YT-NEW',
+        isNative: false,
+        decimals: 18,
+        iconUri: undefined,
+        isVetted: true,
+      },
+      underlyingToken: {
+        tokenUid: { chainId: '42161', address: '0xusdai' },
+        name: 'USDai',
+        symbol: 'USDai',
+        isNative: false,
+        decimals: 18,
+        iconUri: undefined,
+        isVetted: true,
+      },
+    };
+
+    const result = await executeInitialDeposit({
+      onchainActionsClient,
+      clients,
+      txExecutionMode: 'execute',
+      walletAddress: '0x0000000000000000000000000000000000000001',
+      fundingToken,
+      targetMarket,
+      fundingAmount: '10000000',
+    });
+
+    expect(createSwap).toHaveBeenCalledWith({
+      walletAddress: '0x0000000000000000000000000000000000000001',
+      amount: '10000000',
+      amountType: 'exactIn',
+      fromTokenUid: fundingToken.tokenUid,
+      toTokenUid: targetMarket.underlyingToken.tokenUid,
+      slippageTolerance: '0.01',
+    });
+    expect(createTokenizedYieldBuyPt).toHaveBeenCalledWith({
+      walletAddress: '0x0000000000000000000000000000000000000001',
+      marketAddress: targetMarket.marketIdentifier.address,
+      inputTokenUid: targetMarket.underlyingToken.tokenUid,
+      amount: '9500000000000000000',
+      slippage: '0.01',
+    });
+    expect(executeTransactionMock).toHaveBeenCalledTimes(2);
+    expect(executeTransactionMock.mock.calls[0]?.[1]).toMatchObject({ to: '0xswap' });
+    expect(executeTransactionMock.mock.calls[1]?.[1]).toMatchObject({ to: '0xbuy' });
+    expect(result.lastTxHash).toBe('0xbuyhash');
+  });
+
   it('buys PT using the selected funding token directly', async () => {
     const onchainActionsClient: Pick<OnchainActionsClient, 'createTokenizedYieldBuyPt'> = {
       createTokenizedYieldBuyPt: vi.fn().mockResolvedValue({
@@ -728,11 +824,11 @@ describe('executeInitialDeposit', () => {
     const clients = {} as OnchainClients;
 
     const fundingToken = {
-      tokenUid: { chainId: '42161', address: '0xusdc' },
-      name: 'USDC',
-      symbol: 'USDC',
+      tokenUid: { chainId: '42161', address: '0xusdai' },
+      name: 'USDai',
+      symbol: 'USDai',
       isNative: false,
-      decimals: 6,
+      decimals: 18,
       iconUri: undefined,
       isVetted: true,
     };
@@ -809,11 +905,11 @@ describe('executeInitialDeposit', () => {
     const clients = {} as OnchainClients;
 
     const fundingToken = {
-      tokenUid: { chainId: '42161', address: '0xusdc' },
-      name: 'USDC',
-      symbol: 'USDC',
+      tokenUid: { chainId: '42161', address: '0xusdai' },
+      name: 'USDai',
+      symbol: 'USDai',
       isNative: false,
-      decimals: 6,
+      decimals: 18,
       iconUri: undefined,
       isVetted: true,
     };
@@ -905,11 +1001,11 @@ describe('executeInitialDeposit', () => {
     const clients = {} as OnchainClients;
 
     const fundingToken = {
-      tokenUid: { chainId: '42161', address: '0xusdc' },
-      name: 'USDC',
-      symbol: 'USDC',
+      tokenUid: { chainId: '42161', address: '0xusdai' },
+      name: 'USDai',
+      symbol: 'USDai',
       isNative: false,
-      decimals: 6,
+      decimals: 18,
       iconUri: undefined,
       isVetted: true,
     };