BORROW

Instructions

Implementation Reference

• src/tools/borrow.ts:28-76 (handler)

  The execute function of the BORROW tool handler, which orchestrates wallet setup, service call, and response formatting.

  export const borrowTool: Tool<undefined, typeof borrowToolParams> = {
  	name: "BORROW",
  	description: "Borrow tokens from a BAMM position",
  	parameters: borrowToolParams,
  	execute: async (params) => {
  		try {
  			if (!params.borrowToken && !params.borrowTokenSymbol) {
  				return "Error: Either borrowToken address or borrowTokenSymbol is required";
  			}
  
  			const privateKey = process.env.WALLET_PRIVATE_KEY;
  			if (!privateKey) {
  				return "Error: WALLET_PRIVATE_KEY environment variable is not set. Please set it with your wallet's private key (without 0x prefix).";
  			}
  
  			const walletService = new WalletService(privateKey);
  			const borrowService = new BorrowService(walletService);
  
  			const result = await borrowService.execute({
  				bammAddress: params.bammAddress as Address,
  				borrowToken: params.borrowToken as Address | undefined,
  				borrowTokenSymbol: params.borrowTokenSymbol,
  				amount: params.amount,
  			});
  
  			return dedent`
          ✅ Borrowing Successful
  
          🌐 BAMM Address: ${params.bammAddress}
          💸 Amount: ${formatNumber(Number(params.amount))}
          🪙 Token: ${params.borrowTokenSymbol ?? params.borrowToken}
          🔗 Transaction: ${result.txHash}
  
          Tokens have been borrowed from your BAMM position.
        `;
  		} catch (error) {
  			if (error instanceof Error) {
  				return dedent`
            ❌ Borrowing Failed
  
            Error: ${error.message}
  
            Please verify your inputs and try again.
          `;
  			}
  			return "An unknown error occurred while borrowing tokens";
  		}
  	},
  };

• src/tools/borrow.ts:9-24 (schema)

  Zod schema defining the input parameters for the BORROW tool.

  const borrowToolParams = z.object({
  	bammAddress: z
  		.string()
  		.regex(/^0x[a-fA-F0-9]{40}$/)
  		.describe("The address of the BAMM contract"),
  	amount: z.string().min(1).describe("The amount to borrow"),
  	borrowToken: z
  		.string()
  		.regex(/^0x[a-fA-F0-9]{40}$/)
  		.optional()
  		.describe("The address of the token to borrow"),
  	borrowTokenSymbol: z
  		.string()
  		.optional()
  		.describe("The symbol of the token to borrow (e.g., 'IQT')"),
  });

• src/index.ts:20-20 (registration)

  Registration of the borrowTool in the MCP server.

  server.addTool(borrowTool);

• src/services/borrow.ts:16-117 (helper)

  The BorrowService class with the core logic for executing the borrow operation, including token validation, approvals, rent calculation, and BAMM contract interaction.

  export class BorrowService {
  	constructor(private walletService: WalletService) {}
  
  	async execute(params: BorrowParams): Promise<{ txHash: string }> {
  		let { bammAddress, borrowToken, borrowTokenSymbol, amount } = params;
  
  		if (!borrowToken && !borrowTokenSymbol) {
  			throw new Error("Either borrowToken or borrowTokenSymbol is required");
  		}
  		const publicClient = this.walletService.getPublicClient();
  		const walletClient = this.walletService.getWalletClient();
  
  		if (!walletClient || !walletClient.account) {
  			throw new Error("Wallet client is not initialized");
  		}
  
  		const userAddress = walletClient.account.address;
  		const amountInWei = BigInt(Math.floor(Number(amount) * 1e18));
  
  		try {
  			if (borrowTokenSymbol) {
  				borrowToken = await getTokenAddressFromSymbol(borrowTokenSymbol);
  			}
  
  			if (!borrowToken) {
  				throw new Error("Could not resolve borrow token address");
  			}
  
  			const tokenValidation = await validateTokenAgainstBAMM(
  				bammAddress,
  				borrowToken,
  				publicClient,
  			);
  
  			const collateralBalance: bigint = await publicClient.readContract({
  				address: borrowToken,
  				abi: erc20Abi,
  				functionName: "balanceOf",
  				args: [userAddress],
  			});
  			if (collateralBalance < amountInWei) {
  				throw new Error("Insufficient collateral token balance");
  			}
  
  			await checkTokenBalance(
  				borrowToken,
  				userAddress,
  				amountInWei,
  				publicClient,
  			);
  			await ensureTokenApproval(
  				borrowToken,
  				bammAddress,
  				amountInWei,
  				publicClient,
  				walletClient,
  			);
  
  			const rentedMultiplier: bigint = await publicClient.readContract({
  				address: bammAddress,
  				abi: BAMM_ABI,
  				functionName: "rentedMultiplier",
  				args: [],
  			});
  
  			// Calculate rent based on borrowed amount and rentedMultiplier
  			const rent = (amountInWei * rentedMultiplier) / BigInt(1e18);
  
  			const currentTime = Math.floor(Date.now() / 1000);
  			const deadline = BigInt(currentTime + 300);
  
  			const action = {
  				token0Amount: tokenValidation.isToken0 ? -amountInWei : 0n,
  				token1Amount: tokenValidation.isToken1 ? -amountInWei : 0n,
  				rent: rent,
  				to: userAddress,
  				token0AmountMin: 0n,
  				token1AmountMin: 0n,
  				closePosition: false,
  				approveMax: false,
  				v: 0,
  				r: "0x0000000000000000000000000000000000000000000000000000000000000000" as `0x${string}`,
  				s: "0x0000000000000000000000000000000000000000000000000000000000000000" as `0x${string}`,
  				deadline,
  			};
  
  			const { request: executeRequest } = await publicClient.simulateContract({
  				address: bammAddress,
  				abi: BAMM_ABI,
  				functionName: "executeActions",
  				args: [action],
  				account: walletClient.account,
  			});
  			const txHash = await walletClient.writeContract(executeRequest);
  			await publicClient.waitForTransactionReceipt({ hash: txHash });
  
  			return { txHash };
  		} catch (error) {
  			console.error("Error in borrow service", error);
  			throw error;
  		}
  	}

• src/index.ts:4-4 (registration)

  Import statement for the borrowTool.

  import { borrowTool } from "./tools/borrow.js";