feat: add transaction builder functions for interacting with Morpho vaults

src/earn/components/EarnProvider.test.tsx

@@ -0,0 +1,21 @@
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { EarnProvider, useEarnContext } from './EarnProvider';
+
+describe('EarnProvider', () => {
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <EarnProvider vaultAddress="0x123">{children}</EarnProvider>
+  );
+
+  it('provides vault address through context', () => {
+    const { result } = renderHook(() => useEarnContext(), { wrapper });
+
+    expect(result.current.vaultAddress).toBe('0x123');
+  });
+
+  it('throws error when useEarnContext is used outside of provider', () => {
+    expect(() => renderHook(() => useEarnContext())).toThrow(
+      'useEarnContext must be used within an EarnProvider',
+    );
+  });
+});

src/earn/components/EarnProvider.tsx

@@ -0,0 +1,30 @@
+import { useValue } from '@/core-react/internal/hooks/useValue';
+import { type ReactNode, createContext, useContext } from 'react';
+import type { Address } from 'viem';
+
+interface EarnContextType {
+  vaultAddress: Address;
+}
+
+const EarnContext = createContext<EarnContextType | undefined>(undefined);
+
+interface EarnProviderProps {
+  vaultAddress: Address;
+  children: ReactNode;
+}
+
+export function EarnProvider({ vaultAddress, children }: EarnProviderProps) {
+  const value = useValue({
+    vaultAddress,
+  });
+
+  return <EarnContext.Provider value={value}>{children}</EarnContext.Provider>;
+}
+
+export function useEarnContext() {
+  const context = useContext(EarnContext);
+  if (!context) {
+    throw new Error('useEarnContext must be used within an EarnProvider');
+  }
+  return context;
+}

src/earn/constants.ts

@@ -0,0 +1,26 @@
+export const METAMORPHO_ABI = [
+  {
+    inputs: [
+      { internalType: 'uint256', name: 'assets', type: 'uint256' },
+      { internalType: 'address', name: 'receiver', type: 'address' },
+    ],
+    name: 'deposit',
+    outputs: [{ internalType: 'uint256', name: 'shares', type: 'uint256' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { internalType: 'uint256', name: 'assets', type: 'uint256' },
+      { internalType: 'address', name: 'receiver', type: 'address' },
+      { internalType: 'address', name: 'owner', type: 'address' },
+    ],
+    name: 'withdraw',
+    outputs: [{ internalType: 'uint256', name: 'shares', type: 'uint256' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+export const USDC_ADDRESS = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+export const USDC_DECIMALS = 6;

src/earn/index.ts

@@ -0,0 +1,2 @@
+// 🌲☀🌲
+// Components

src/earn/utils/deposit.test.ts

@@ -0,0 +1,89 @@
+import { METAMORPHO_ABI, USDC_ADDRESS, USDC_DECIMALS } from '@/earn/constants';
+import { encodeFunctionData, parseUnits } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { buildDepositToMorphoTx } from './deposit';
+
+describe('buildDepositToMorphoTx', () => {
+  const mockArgs = {
+    vaultAddress: '0xd63070114470f685b75B74D60EEc7c1113d33a3D',
+    tokenAddress: USDC_ADDRESS,
+    amount: parseUnits('1000', USDC_DECIMALS),
+    receiverAddress: '0x9E95f497a7663B70404496dB6481c890C4825fe1',
+  } as const;
+
+  it('should return an array with two transactions', async () => {
+    const result = buildDepositToMorphoTx(mockArgs);
+    expect(result).toHaveLength(2);
+  });
+
+  it('should build correct approve transaction', async () => {
+    const result = buildDepositToMorphoTx(mockArgs);
+    const expectedAmount = mockArgs.amount;
+
+    const expectedApproveData = encodeFunctionData({
+      abi: [
+        {
+          name: 'approve',
+          type: 'function',
+          inputs: [
+            { name: 'spender', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+          ],
+          outputs: [{ type: 'bool' }],
+          stateMutability: 'nonpayable',
+        },
+      ],
+      functionName: 'approve',
+      args: [mockArgs.vaultAddress, expectedAmount],
+    });
+
+    expect(result[0]).toEqual({
+      to: mockArgs.tokenAddress,
+      data: expectedApproveData,
+    });
+  });
+
+  it('should build correct deposit transaction', async () => {
+    const result = buildDepositToMorphoTx(mockArgs);
+    const expectedAmount = mockArgs.amount;
+
+    const expectedDepositData = encodeFunctionData({
+      abi: METAMORPHO_ABI,
+      functionName: 'deposit',
+      args: [expectedAmount, mockArgs.receiverAddress],
+    });
+
+    expect(result[1]).toEqual({
+      to: mockArgs.vaultAddress,
+      data: expectedDepositData,
+    });
+  });
+
+  it('should handle zero amount', async () => {
+    const result = buildDepositToMorphoTx({
+      ...mockArgs,
+      amount: 0n,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result[0].to).toBe(mockArgs.tokenAddress);
+    expect(result[1].to).toBe(mockArgs.vaultAddress);
+  });
+
+  it('should handle decimal amounts', async () => {
+    const result = buildDepositToMorphoTx({
+      ...mockArgs,
+      amount: parseUnits('100.5', USDC_DECIMALS),
+    });
+
+    const expectedAmount = parseUnits('100.5', USDC_DECIMALS);
+    expect(result).toHaveLength(2);
+    expect(
+      encodeFunctionData({
+        abi: METAMORPHO_ABI,
+        functionName: 'deposit',
+        args: [expectedAmount, mockArgs.receiverAddress],
+      }),
+    ).toBe(result[1].data);
+  });
+});

src/earn/utils/deposit.ts

@@ -0,0 +1,42 @@
+import { METAMORPHO_ABI } from '@/earn/constants';
+import type { Call } from '@/transaction/types';
+import { type Address, encodeFunctionData, erc20Abi } from 'viem';
+
+type DepositToMorphoArgs = {
+  vaultAddress: Address;
+  tokenAddress: Address;
+  amount: bigint;
+  receiverAddress: Address;
+};
+
+export function buildDepositToMorphoTx({
+  vaultAddress,
+  tokenAddress,
+  amount,
+  receiverAddress,
+}: DepositToMorphoArgs): Call[] {
+  // User needs to approve the token they're depositing
+  const approveTxData = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: 'approve',
+    args: [vaultAddress, amount],
+  });
+
+  // Once approved, user can deposit the token into the vault
+  const depositTxData = encodeFunctionData({
+    abi: METAMORPHO_ABI,
+    functionName: 'deposit',
+    args: [amount, receiverAddress],
+  });
+
+  return [
+    {
+      to: tokenAddress,
+      data: approveTxData,
+    },
+    {
+      to: vaultAddress,
+      data: depositTxData,
+    },
+  ];
+}

src/earn/utils/withdraw.test.ts

@@ -0,0 +1,79 @@
+import { METAMORPHO_ABI, USDC_DECIMALS } from '@/earn/constants';
+import { encodeFunctionData, parseUnits } from 'viem';
+import { describe, expect, it } from 'vitest';
+import { buildWithdrawFromMorphoTx } from './withdraw';
+
+describe('buildWithdrawFromMorphoTx', () => {
+  const mockArgs = {
+    vaultAddress: '0xd63070114470f685b75B74D60EEc7c1113d33a3D',
+    amount: parseUnits('1000', USDC_DECIMALS),
+    receiverAddress: '0x9E95f497a7663B70404496dB6481c890C4825fe1',
+  } as const;
+
+  it('should return an array with one transaction', async () => {
+    const result = await buildWithdrawFromMorphoTx(mockArgs);
+    expect(result).toHaveLength(1);
+  });
+
+  it('should build correct withdraw transaction', async () => {
+    const result = await buildWithdrawFromMorphoTx(mockArgs);
+    const expectedAmount = mockArgs.amount;
+
+    const expectedWithdrawData = encodeFunctionData({
+      abi: METAMORPHO_ABI,
+      functionName: 'withdraw',
+      args: [
+        expectedAmount,
+        mockArgs.receiverAddress,
+        mockArgs.receiverAddress,
+      ],
+    });
+
+    expect(result[0]).toEqual({
+      to: mockArgs.vaultAddress,
+      data: expectedWithdrawData,
+    });
+  });
+
+  it('should handle zero amount', async () => {
+    const result = await buildWithdrawFromMorphoTx({
+      ...mockArgs,
+      amount: 0n,
+    });
+
+    const expectedAmount = parseUnits('0', USDC_DECIMALS);
+    expect(result).toHaveLength(1);
+    expect(
+      encodeFunctionData({
+        abi: METAMORPHO_ABI,
+        functionName: 'withdraw',
+        args: [
+          expectedAmount,
+          mockArgs.receiverAddress,
+          mockArgs.receiverAddress,
+        ],
+      }),
+    ).toBe(result[0].data);
+  });
+
+  it('should handle decimal amounts', async () => {
+    const result = await buildWithdrawFromMorphoTx({
+      ...mockArgs,
+      amount: parseUnits('100.5', USDC_DECIMALS),
+    });
+
+    const expectedAmount = parseUnits('100.5', USDC_DECIMALS);
+    expect(result).toHaveLength(1);
+    expect(
+      encodeFunctionData({
+        abi: METAMORPHO_ABI,
+        functionName: 'withdraw',
+        args: [
+          expectedAmount,
+          mockArgs.receiverAddress,
+          mockArgs.receiverAddress,
+        ],
+      }),
+    ).toBe(result[0].data);
+  });
+});

src/earn/utils/withdraw.ts

@@ -0,0 +1,28 @@
+import { METAMORPHO_ABI } from '@/earn/constants';
+import type { Call } from '@/transaction/types';
+import { type Address, encodeFunctionData } from 'viem';
+
+type WithdrawFromMorphoArgs = {
+  vaultAddress: Address;
+  amount: bigint;
+  receiverAddress: Address;
+};
+
+export async function buildWithdrawFromMorphoTx({
+  vaultAddress,
+  amount,
+  receiverAddress,
+}: WithdrawFromMorphoArgs): Promise<Call[]> {
+  const withdrawTxData = encodeFunctionData({
+    abi: METAMORPHO_ABI,
+    functionName: 'withdraw',
+    args: [amount, receiverAddress, receiverAddress],
+  });
+
+  return [
+    {
+      to: vaultAddress,
+      data: withdrawTxData,
+    },
+  ];
+}