@compass-labs/api-sdk 0.5.13 → 0.5.14

package/bin/mcp-server.js

@@ -34205,9 +34205,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.0.1",
-    sdkVersion: "0.5.13",
-    genVersion: "2.623.2",
-    userAgent: "speakeasy-sdk/typescript 0.5.13 2.623.2 0.0.1 @compass-labs/api-sdk"
+    sdkVersion: "0.5.14",
+    genVersion: "2.628.0",
+    userAgent: "speakeasy-sdk/typescript 0.5.14 2.628.0 0.0.1 @compass-labs/api-sdk"
   };
 });
 
@@ -36248,6 +36248,128 @@ var init_aaveliquiditychangeresponse = __esm(() => {
   })(AaveLiquidityChangeResponse$ ||= {});
 });
 
+// src/models/components/signedauthorization.ts
+var R$inboundSchema, R$outboundSchema, R$, S$inboundSchema, S$outboundSchema, S$, SignedAuthorization$inboundSchema, SignedAuthorization$outboundSchema, SignedAuthorization$;
+var init_signedauthorization = __esm(() => {
+  init_esm();
+  R$inboundSchema = unionType([
+    numberType().int(),
+    stringType()
+  ]);
+  R$outboundSchema = unionType([numberType().int(), stringType()]);
+  ((R$) => {
+    R$.inboundSchema = R$inboundSchema;
+    R$.outboundSchema = R$outboundSchema;
+  })(R$ ||= {});
+  S$inboundSchema = unionType([
+    numberType().int(),
+    stringType()
+  ]);
+  S$outboundSchema = unionType([numberType().int(), stringType()]);
+  ((S$) => {
+    S$.inboundSchema = S$inboundSchema;
+    S$.outboundSchema = S$outboundSchema;
+  })(S$ ||= {});
+  SignedAuthorization$inboundSchema = objectType({
+    nonce: numberType().int(),
+    address: stringType(),
+    chainId: numberType().int(),
+    r: unionType([numberType().int(), stringType()]),
+    s: unionType([numberType().int(), stringType()]),
+    yParity: numberType().int()
+  });
+  SignedAuthorization$outboundSchema = objectType({
+    nonce: numberType().int(),
+    address: stringType(),
+    chainId: numberType().int(),
+    r: unionType([numberType().int(), stringType()]),
+    s: unionType([numberType().int(), stringType()]),
+    yParity: numberType().int()
+  });
+  ((SignedAuthorization$) => {
+    SignedAuthorization$.inboundSchema = SignedAuthorization$inboundSchema;
+    SignedAuthorization$.outboundSchema = SignedAuthorization$outboundSchema;
+  })(SignedAuthorization$ ||= {});
+});
+
+// src/models/components/aavelooprequest.ts
+var InitialCollateralAmount$inboundSchema, InitialCollateralAmount$outboundSchema, InitialCollateralAmount$, Multiplier$inboundSchema, Multiplier$outboundSchema, Multiplier$, MaxSlippagePercent$inboundSchema, MaxSlippagePercent$outboundSchema, MaxSlippagePercent$, LoanToValue$inboundSchema, LoanToValue$outboundSchema, LoanToValue$, AaveLoopRequest$inboundSchema, AaveLoopRequest$outboundSchema, AaveLoopRequest$;
+var init_aavelooprequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_chain();
+  init_signedauthorization();
+  init_tokenenum();
+  InitialCollateralAmount$inboundSchema = unionType([numberType(), stringType()]);
+  InitialCollateralAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((InitialCollateralAmount$) => {
+    InitialCollateralAmount$.inboundSchema = InitialCollateralAmount$inboundSchema;
+    InitialCollateralAmount$.outboundSchema = InitialCollateralAmount$outboundSchema;
+  })(InitialCollateralAmount$ ||= {});
+  Multiplier$inboundSchema = unionType([numberType(), stringType()]);
+  Multiplier$outboundSchema = unionType([numberType(), stringType()]);
+  ((Multiplier$) => {
+    Multiplier$.inboundSchema = Multiplier$inboundSchema;
+    Multiplier$.outboundSchema = Multiplier$outboundSchema;
+  })(Multiplier$ ||= {});
+  MaxSlippagePercent$inboundSchema = unionType([numberType(), stringType()]);
+  MaxSlippagePercent$outboundSchema = unionType([numberType(), stringType()]);
+  ((MaxSlippagePercent$) => {
+    MaxSlippagePercent$.inboundSchema = MaxSlippagePercent$inboundSchema;
+    MaxSlippagePercent$.outboundSchema = MaxSlippagePercent$outboundSchema;
+  })(MaxSlippagePercent$ ||= {});
+  LoanToValue$inboundSchema = unionType([numberType(), stringType()]);
+  LoanToValue$outboundSchema = unionType([numberType(), stringType()]);
+  ((LoanToValue$) => {
+    LoanToValue$.inboundSchema = LoanToValue$inboundSchema;
+    LoanToValue$.outboundSchema = LoanToValue$outboundSchema;
+  })(LoanToValue$ ||= {});
+  AaveLoopRequest$inboundSchema = objectType({
+    chain: Chain$inboundSchema,
+    sender: stringType(),
+    signed_authorization: SignedAuthorization$inboundSchema,
+    collateral_token: TokenEnum$inboundSchema,
+    borrow_token: TokenEnum$inboundSchema,
+    initial_collateral_amount: unionType([numberType(), stringType()]),
+    multiplier: unionType([numberType(), stringType()]),
+    max_slippage_percent: unionType([numberType(), stringType()]),
+    loan_to_value: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      signed_authorization: "signedAuthorization",
+      collateral_token: "collateralToken",
+      borrow_token: "borrowToken",
+      initial_collateral_amount: "initialCollateralAmount",
+      max_slippage_percent: "maxSlippagePercent",
+      loan_to_value: "loanToValue"
+    });
+  });
+  AaveLoopRequest$outboundSchema = objectType({
+    chain: Chain$outboundSchema,
+    sender: stringType(),
+    signedAuthorization: SignedAuthorization$outboundSchema,
+    collateralToken: TokenEnum$outboundSchema,
+    borrowToken: TokenEnum$outboundSchema,
+    initialCollateralAmount: unionType([numberType(), stringType()]),
+    multiplier: unionType([numberType(), stringType()]),
+    maxSlippagePercent: unionType([numberType(), stringType()]),
+    loanToValue: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      signedAuthorization: "signed_authorization",
+      collateralToken: "collateral_token",
+      borrowToken: "borrow_token",
+      initialCollateralAmount: "initial_collateral_amount",
+      maxSlippagePercent: "max_slippage_percent",
+      loanToValue: "loan_to_value"
+    });
+  });
+  ((AaveLoopRequest$) => {
+    AaveLoopRequest$.inboundSchema = AaveLoopRequest$inboundSchema;
+    AaveLoopRequest$.outboundSchema = AaveLoopRequest$outboundSchema;
+  })(AaveLoopRequest$ ||= {});
+});
+
 // src/models/components/aaverateresponse.ts
 var AaveRateResponse$inboundSchema, AaveRateResponse$outboundSchema, AaveRateResponse$;
 var init_aaverateresponse = __esm(() => {
@@ -39361,25 +39483,25 @@ var init_compassapibackendmodelsmorphoreadresponsegetmarketmarketstate = __esm((
   init_esm();
   CompassApiBackendModelsMorphoReadResponseGetMarketMarketState$inboundSchema = objectType({
     utilization: stringType(),
-    collateralAssets: stringType(),
+    collateralAssets: nullableType(stringType()).optional(),
     collateralAssetsUsd: nullableType(stringType()).optional(),
     borrowAssets: stringType(),
-    borrowAssetsUsd: stringType(),
+    borrowAssetsUsd: nullableType(stringType()).optional(),
     liquidityAssets: stringType(),
-    liquidityAssetsUsd: stringType(),
+    liquidityAssetsUsd: nullableType(stringType()).optional(),
     totalLiquidity: stringType(),
-    totalLiquidityUsd: stringType()
+    totalLiquidityUsd: nullableType(stringType()).optional()
   });
   CompassApiBackendModelsMorphoReadResponseGetMarketMarketState$outboundSchema = objectType({
     utilization: stringType(),
-    collateralAssets: stringType(),
+    collateralAssets: nullableType(stringType()).optional(),
     collateralAssetsUsd: nullableType(stringType()).optional(),
     borrowAssets: stringType(),
-    borrowAssetsUsd: stringType(),
+    borrowAssetsUsd: nullableType(stringType()).optional(),
     liquidityAssets: stringType(),
-    liquidityAssetsUsd: stringType(),
+    liquidityAssetsUsd: nullableType(stringType()).optional(),
     totalLiquidity: stringType(),
-    totalLiquidityUsd: stringType()
+    totalLiquidityUsd: nullableType(stringType()).optional()
   });
   ((CompassApiBackendModelsMorphoReadResponseGetMarketMarketState$) => {
     CompassApiBackendModelsMorphoReadResponseGetMarketMarketState$.inboundSchema = CompassApiBackendModelsMorphoReadResponseGetMarketMarketState$inboundSchema;
@@ -39887,14 +40009,10 @@ var init_metadata = __esm(() => {
   init_esm();
   init_curator();
   Metadata$inboundSchema = objectType({
-    description: nullableType(stringType()),
-    image: nullableType(stringType()),
     forumLink: nullableType(stringType()),
     curators: arrayType(Curator$inboundSchema)
   });
   Metadata$outboundSchema = objectType({
-    description: nullableType(stringType()),
-    image: nullableType(stringType()),
     forumLink: nullableType(stringType()),
     curators: arrayType(Curator$outboundSchema)
   });
@@ -40649,6 +40767,79 @@ var init_morphowithdrawrequest = __esm(() => {
   })(MorphoWithdrawRequest$ ||= {});
 });
 
+// src/models/components/multicallauthorizationrequest.ts
+var MulticallAuthorizationRequest$inboundSchema, MulticallAuthorizationRequest$outboundSchema, MulticallAuthorizationRequest$;
+var init_multicallauthorizationrequest = __esm(() => {
+  init_esm();
+  init_chain();
+  MulticallAuthorizationRequest$inboundSchema = objectType({
+    chain: Chain$inboundSchema,
+    sender: stringType()
+  });
+  MulticallAuthorizationRequest$outboundSchema = objectType({
+    chain: Chain$outboundSchema,
+    sender: stringType()
+  });
+  ((MulticallAuthorizationRequest$) => {
+    MulticallAuthorizationRequest$.inboundSchema = MulticallAuthorizationRequest$inboundSchema;
+    MulticallAuthorizationRequest$.outboundSchema = MulticallAuthorizationRequest$outboundSchema;
+  })(MulticallAuthorizationRequest$ ||= {});
+});
+
+// src/models/components/multicallauthorizationresponse.ts
+var MulticallAuthorizationResponse$inboundSchema, MulticallAuthorizationResponse$outboundSchema, MulticallAuthorizationResponse$;
+var init_multicallauthorizationresponse = __esm(() => {
+  init_esm();
+  MulticallAuthorizationResponse$inboundSchema = objectType({
+    nonce: numberType().int(),
+    address: stringType(),
+    chainId: numberType().int()
+  });
+  MulticallAuthorizationResponse$outboundSchema = objectType({
+    nonce: numberType().int(),
+    address: stringType(),
+    chainId: numberType().int()
+  });
+  ((MulticallAuthorizationResponse$) => {
+    MulticallAuthorizationResponse$.inboundSchema = MulticallAuthorizationResponse$inboundSchema;
+    MulticallAuthorizationResponse$.outboundSchema = MulticallAuthorizationResponse$outboundSchema;
+  })(MulticallAuthorizationResponse$ ||= {});
+});
+
+// src/models/components/multicallexecuterequest.ts
+var MulticallExecuteRequest$inboundSchema, MulticallExecuteRequest$outboundSchema, MulticallExecuteRequest$;
+var init_multicallexecuterequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_chain();
+  init_signedauthorization();
+  init_useroperation();
+  MulticallExecuteRequest$inboundSchema = objectType({
+    chain: Chain$inboundSchema,
+    sender: stringType(),
+    signed_authorization: SignedAuthorization$inboundSchema,
+    actions: arrayType(UserOperation$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      signed_authorization: "signedAuthorization"
+    });
+  });
+  MulticallExecuteRequest$outboundSchema = objectType({
+    chain: Chain$outboundSchema,
+    sender: stringType(),
+    signedAuthorization: SignedAuthorization$outboundSchema,
+    actions: arrayType(UserOperation$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      signedAuthorization: "signed_authorization"
+    });
+  });
+  ((MulticallExecuteRequest$) => {
+    MulticallExecuteRequest$.inboundSchema = MulticallExecuteRequest$inboundSchema;
+    MulticallExecuteRequest$.outboundSchema = MulticallExecuteRequest$outboundSchema;
+  })(MulticallExecuteRequest$ ||= {});
+});
+
 // src/models/components/openposition.ts
 var OpenPosition$inboundSchema, OpenPosition$outboundSchema, OpenPosition$;
 var init_openposition = __esm(() => {
@@ -41236,50 +41427,6 @@ var init_security2 = __esm(() => {
   })(Security$ ||= {});
 });
 
-// src/models/components/signedauthorization.ts
-var R$inboundSchema, R$outboundSchema, R$, S$inboundSchema, S$outboundSchema, S$, SignedAuthorization$inboundSchema, SignedAuthorization$outboundSchema, SignedAuthorization$;
-var init_signedauthorization = __esm(() => {
-  init_esm();
-  R$inboundSchema = unionType([
-    numberType().int(),
-    stringType()
-  ]);
-  R$outboundSchema = unionType([numberType().int(), stringType()]);
-  ((R$) => {
-    R$.inboundSchema = R$inboundSchema;
-    R$.outboundSchema = R$outboundSchema;
-  })(R$ ||= {});
-  S$inboundSchema = unionType([
-    numberType().int(),
-    stringType()
-  ]);
-  S$outboundSchema = unionType([numberType().int(), stringType()]);
-  ((S$) => {
-    S$.inboundSchema = S$inboundSchema;
-    S$.outboundSchema = S$outboundSchema;
-  })(S$ ||= {});
-  SignedAuthorization$inboundSchema = objectType({
-    nonce: numberType().int(),
-    address: stringType(),
-    chainId: numberType().int(),
-    r: unionType([numberType().int(), stringType()]),
-    s: unionType([numberType().int(), stringType()]),
-    yParity: numberType().int()
-  });
-  SignedAuthorization$outboundSchema = objectType({
-    nonce: numberType().int(),
-    address: stringType(),
-    chainId: numberType().int(),
-    r: unionType([numberType().int(), stringType()]),
-    s: unionType([numberType().int(), stringType()]),
-    yParity: numberType().int()
-  });
-  ((SignedAuthorization$) => {
-    SignedAuthorization$.inboundSchema = SignedAuthorization$inboundSchema;
-    SignedAuthorization$.outboundSchema = SignedAuthorization$outboundSchema;
-  })(SignedAuthorization$ ||= {});
-});
-
 // src/models/components/skybuyrequest.ts
 var SkyBuyRequestTokenIn, SkyBuyRequestTokenIn$inboundSchema, SkyBuyRequestTokenIn$outboundSchema, SkyBuyRequestTokenIn$, SkyBuyRequestAmount$inboundSchema, SkyBuyRequestAmount$outboundSchema, SkyBuyRequestAmount$, SkyBuyRequest$inboundSchema, SkyBuyRequest$outboundSchema, SkyBuyRequest$;
 var init_skybuyrequest = __esm(() => {
@@ -42331,6 +42478,7 @@ var init_components = __esm(() => {
   init_aaveborrowrequest();
   init_aavehistoricaltransactionsresponse();
   init_aaveliquiditychangeresponse();
+  init_aavelooprequest();
   init_aaverateresponse();
   init_aaverepayparams();
   init_aaverepayrequest();
@@ -42416,6 +42564,9 @@ var init_components = __esm(() => {
   init_morphowithdrawparams();
   init_morphowithdrawrequest();
   init_movement10percent();
+  init_multicallauthorizationrequest();
+  init_multicallauthorizationresponse();
+  init_multicallexecuterequest();
   init_openposition();
   init_pendleaddliquidityparams();
   init_pendleaddliquidityrequest();
@@ -50963,18 +51114,18 @@ Sends native ETH or ERC20 tokens from the sender's address to another address.`,
   };
 });
 
-// src/funcs/uniswapV3LiquidityProvisionIncrease.ts
-function uniswapV3LiquidityProvisionIncrease(client, request, options) {
+// src/funcs/transactionBatchingAaveLoop.ts
+function transactionBatchingAaveLoop(client, request, options) {
   return new APIPromise($do56(client, request, options));
 }
 async function $do56(client, request, options) {
-  const parsed = safeParse(request, (value) => UniswapIncreaseLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => AaveLoopRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = encodeJSON("body", payload, { explode: true });
-  const path = pathToFunc("/v0/uniswap/liquidity_provision/increase")();
+  const path = pathToFunc("/v0/multicall/aave/loop")();
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json"
@@ -50985,7 +51136,7 @@ async function $do56(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uniswap_liquidity_provision_increase",
+    operationID: "multicall_aave_loop",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.apiKeyAuth,
@@ -51019,13 +51170,13 @@ async function $do56(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, TxResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, UnsignedMulticallTransaction$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_uniswapV3LiquidityProvisionIncrease = __esm(() => {
+var init_transactionBatchingAaveLoop = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -51037,31 +51188,33 @@ var init_uniswapV3LiquidityProvisionIncrease = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/uniswapV3LiquidityProvisionIncrease.ts
-var args56, tool$uniswapV3LiquidityProvisionIncrease;
-var init_uniswapV3LiquidityProvisionIncrease2 = __esm(() => {
-  init_uniswapV3LiquidityProvisionIncrease();
+// src/mcp-server/tools/transactionBatchingAaveLoop.ts
+var args56, tool$transactionBatchingAaveLoop;
+var init_transactionBatchingAaveLoop2 = __esm(() => {
+  init_transactionBatchingAaveLoop();
   init_components();
   init_tools();
   args56 = {
-    request: UniswapIncreaseLiquidityProvisionRequest$inboundSchema
+    request: AaveLoopRequest$inboundSchema
   };
-  tool$uniswapV3LiquidityProvisionIncrease = {
-    name: "uniswap-v3-liquidity-provision-increase",
-    description: `Increase an LP position
+  tool$transactionBatchingAaveLoop = {
+    name: "transaction-batching-aave-loop",
+    description: `AAVE leverage long/short
 
-This endpoint allows users to increase their existing Liquidity Provider (LP)
-positions on the Uniswap platform.
+Execute an Aave looping strategy that involves repeated supply and borrow
+operations.
 
-By providing the necessary parameters, users can add more liquidity to their current
-positions, thereby increasing their stake in the liquidity pool. This operation is
-beneficial for users who wish to enhance their potential earnings from trading fees
-within the pool. The endpoint requires details such as the token pair, additional
-amount to be added, and any other parameters necessary for the liquidity increase
-process.`,
+This endpoint creates a multicall transaction that performs a series of operations:
+1. Approves and supplies initial token
+2. For each loop:
+    - Borrows another token
+    - Swaps borrowed token back to supply token
+    - Supplies the swapped tokens
+
+The transaction must be authorized using the /authorization endpoint to prevent replay attacks.`,
     args: args56,
     tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionIncrease(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await transactionBatchingAaveLoop(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51074,23 +51227,20 @@ process.`,
   };
 });
 
-// src/funcs/uniswapV3LiquidityProvisionInRange.ts
-function uniswapV3LiquidityProvisionInRange(client, request, options) {
+// src/funcs/transactionBatchingAuthorization.ts
+function transactionBatchingAuthorization(client, request, options) {
   return new APIPromise($do57(client, request, options));
 }
 async function $do57(client, request, options) {
-  const parsed = safeParse(request, (value) => UniswapLiquidityProvisionInRangeRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => MulticallAuthorizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
-  const path = pathToFunc("/v0/uniswap/liquidity_provision/in_range/get")();
-  const query = encodeFormQuery({
-    chain: payload.chain,
-    token_id: payload.token_id
-  });
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v0/multicall/authorization")();
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.apiKeyAuth);
@@ -51099,7 +51249,7 @@ async function $do57(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uniswap_liquidity_provision_in_range",
+    operationID: "multicall_authorization",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.apiKeyAuth,
@@ -51108,11 +51258,10 @@ async function $do57(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -51134,13 +51283,13 @@ async function $do57(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, UniswapCheckInRangeResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, MulticallAuthorizationResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_uniswapV3LiquidityProvisionInRange = __esm(() => {
+var init_transactionBatchingAuthorization = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -51149,34 +51298,31 @@ var init_uniswapV3LiquidityProvisionInRange = __esm(() => {
   init_url();
   init_components();
   init_errors2();
-  init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/uniswapV3LiquidityProvisionInRange.ts
-var args57, tool$uniswapV3LiquidityProvisionInRange;
-var init_uniswapV3LiquidityProvisionInRange2 = __esm(() => {
-  init_uniswapV3LiquidityProvisionInRange();
-  init_operations();
+// src/mcp-server/tools/transactionBatchingAuthorization.ts
+var args57, tool$transactionBatchingAuthorization;
+var init_transactionBatchingAuthorization2 = __esm(() => {
+  init_transactionBatchingAuthorization();
+  init_components();
   init_tools();
   args57 = {
-    request: UniswapLiquidityProvisionInRangeRequest$inboundSchema
+    request: MulticallAuthorizationRequest$inboundSchema
   };
-  tool$uniswapV3LiquidityProvisionInRange = {
-    name: "uniswap-v3-liquidity-provision-in-range",
-    description: `Check if LP is active.
+  tool$transactionBatchingAuthorization = {
+    name: "transaction-batching-authorization",
+    description: `Enable transaction bundling.
 
-This endpoint allows users to check whether a specific liquidity provider ()
-position is within the active tick range on the uniswap platform.
+Get authorization for bundling transactions.
 
-by providing the token id associated with the position, users can verify if the
-position is currently within the tick range where trading occurs. this information
-is essential for users to monitor the status of their lp positions and ensure that
-they are actively participating in the trading activities within the liquidity pool
-and earning trading fees.`,
+Currently this is required for every transaction bundle to prevent replay attacks
+and ensure transaction ordering when batching multiple actions into a single
+transaction. The authorization includes a nonce and chain ID to guarantee
+transaction uniqueness and proper network targeting.`,
     args: args57,
     tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionInRange(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await transactionBatchingAuthorization(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51189,18 +51335,18 @@ and earning trading fees.`,
   };
 });
 
-// src/funcs/uniswapV3LiquidityProvisionMint.ts
-function uniswapV3LiquidityProvisionMint(client, request, options) {
+// src/funcs/transactionBatchingExecute.ts
+function transactionBatchingExecute(client, request, options) {
   return new APIPromise($do58(client, request, options));
 }
 async function $do58(client, request, options) {
-  const parsed = safeParse(request, (value) => UniswapMintLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => MulticallExecuteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = encodeJSON("body", payload, { explode: true });
-  const path = pathToFunc("/v0/uniswap/liquidity_provision/mint")();
+  const path = pathToFunc("/v0/multicall/execute")();
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json"
@@ -51211,7 +51357,7 @@ async function $do58(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uniswap_liquidity_provision_mint",
+    operationID: "multicall_execute",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.apiKeyAuth,
@@ -51245,13 +51391,13 @@ async function $do58(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, TxResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, UnsignedMulticallTransaction$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_uniswapV3LiquidityProvisionMint = __esm(() => {
+var init_transactionBatchingExecute = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -51263,31 +51409,29 @@ var init_uniswapV3LiquidityProvisionMint = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/uniswapV3LiquidityProvisionMint.ts
-var args58, tool$uniswapV3LiquidityProvisionMint;
-var init_uniswapV3LiquidityProvisionMint2 = __esm(() => {
-  init_uniswapV3LiquidityProvisionMint();
+// src/mcp-server/tools/transactionBatchingExecute.ts
+var args58, tool$transactionBatchingExecute;
+var init_transactionBatchingExecute2 = __esm(() => {
+  init_transactionBatchingExecute();
   init_components();
   init_tools();
   args58 = {
-    request: UniswapMintLiquidityProvisionRequest$inboundSchema
+    request: MulticallExecuteRequest$inboundSchema
   };
-  tool$uniswapV3LiquidityProvisionMint = {
-    name: "uniswap-v3-liquidity-provision-mint",
-    description: `Open a new LP position
+  tool$transactionBatchingExecute = {
+    name: "transaction-batching-execute",
+    description: `Construct Bundled Transaction
 
-This endpoint allows users to open a new Liquidity Provider (LP) position on the
-Uniswap platform.
+Bundle arbitrary transactions together into a single multicall transaction using
+EIP-7702.
 
-By providing the necessary parameters, users can initiate a minting process to
-create a new LP token, which represents their stake in a specific liquidity pool.
-This operation is essential for users looking to participate in liquidity provision,
-enabling them to earn fees from trades that occur within the pool. The endpoint
-requires details such as the token pair, amount, and any additional parameters
-needed for the minting process.`,
+This endpoint allows bundling multiple contract calls into a single atomic
+transaction, reducing gas costs and ensuring all operations succeed or fail
+together. The transaction must be authorized using the /authorization endpoint to
+prevent replay attacks.`,
     args: args58,
     tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionMint(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await transactionBatchingExecute(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51300,23 +51444,20 @@ needed for the minting process.`,
   };
 });
 
-// src/funcs/uniswapV3LiquidityProvisionPositions.ts
-function uniswapV3LiquidityProvisionPositions(client, request, options) {
+// src/funcs/uniswapV3LiquidityProvisionIncrease.ts
+function uniswapV3LiquidityProvisionIncrease(client, request, options) {
   return new APIPromise($do59(client, request, options));
 }
 async function $do59(client, request, options) {
-  const parsed = safeParse(request, (value) => UniswapLiquidityProvisionPositionsRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => UniswapIncreaseLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
-  const path = pathToFunc("/v0/uniswap/liquidity_provision/positions/get")();
-  const query = encodeFormQuery({
-    chain: payload.chain,
-    user: payload.user
-  });
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v0/uniswap/liquidity_provision/increase")();
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.apiKeyAuth);
@@ -51325,7 +51466,7 @@ async function $do59(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uniswap_liquidity_provision_positions",
+    operationID: "uniswap_liquidity_provision_increase",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.apiKeyAuth,
@@ -51334,11 +51475,10 @@ async function $do59(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -51360,13 +51500,13 @@ async function $do59(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, UniswapLPPositionsInfoResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  const [result] = await match(json(200, TxResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_uniswapV3LiquidityProvisionPositions = __esm(() => {
+var init_uniswapV3LiquidityProvisionIncrease = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -51375,17 +51515,358 @@ var init_uniswapV3LiquidityProvisionPositions = __esm(() => {
   init_url();
   init_components();
   init_errors2();
-  init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/uniswapV3LiquidityProvisionPositions.ts
-var args59, tool$uniswapV3LiquidityProvisionPositions;
-var init_uniswapV3LiquidityProvisionPositions2 = __esm(() => {
-  init_uniswapV3LiquidityProvisionPositions();
-  init_operations();
-  init_tools();
+// src/mcp-server/tools/uniswapV3LiquidityProvisionIncrease.ts
+var args59, tool$uniswapV3LiquidityProvisionIncrease;
+var init_uniswapV3LiquidityProvisionIncrease2 = __esm(() => {
+  init_uniswapV3LiquidityProvisionIncrease();
+  init_components();
+  init_tools();
   args59 = {
+    request: UniswapIncreaseLiquidityProvisionRequest$inboundSchema
+  };
+  tool$uniswapV3LiquidityProvisionIncrease = {
+    name: "uniswap-v3-liquidity-provision-increase",
+    description: `Increase an LP position
+
+This endpoint allows users to increase their existing Liquidity Provider (LP)
+positions on the Uniswap platform.
+
+By providing the necessary parameters, users can add more liquidity to their current
+positions, thereby increasing their stake in the liquidity pool. This operation is
+beneficial for users who wish to enhance their potential earnings from trading fees
+within the pool. The endpoint requires details such as the token pair, additional
+amount to be added, and any other parameters necessary for the liquidity increase
+process.`,
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionIncrease(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/uniswapV3LiquidityProvisionInRange.ts
+function uniswapV3LiquidityProvisionInRange(client, request, options) {
+  return new APIPromise($do60(client, request, options));
+}
+async function $do60(client, request, options) {
+  const parsed = safeParse(request, (value) => UniswapLiquidityProvisionInRangeRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/v0/uniswap/liquidity_provision/in_range/get")();
+  const query = encodeFormQuery({
+    chain: payload.chain,
+    token_id: payload.token_id
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "uniswap_liquidity_provision_in_range",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, UniswapCheckInRangeResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_uniswapV3LiquidityProvisionInRange = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/uniswapV3LiquidityProvisionInRange.ts
+var args60, tool$uniswapV3LiquidityProvisionInRange;
+var init_uniswapV3LiquidityProvisionInRange2 = __esm(() => {
+  init_uniswapV3LiquidityProvisionInRange();
+  init_operations();
+  init_tools();
+  args60 = {
+    request: UniswapLiquidityProvisionInRangeRequest$inboundSchema
+  };
+  tool$uniswapV3LiquidityProvisionInRange = {
+    name: "uniswap-v3-liquidity-provision-in-range",
+    description: `Check if LP is active.
+
+This endpoint allows users to check whether a specific liquidity provider ()
+position is within the active tick range on the uniswap platform.
+
+by providing the token id associated with the position, users can verify if the
+position is currently within the tick range where trading occurs. this information
+is essential for users to monitor the status of their lp positions and ensure that
+they are actively participating in the trading activities within the liquidity pool
+and earning trading fees.`,
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionInRange(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/uniswapV3LiquidityProvisionMint.ts
+function uniswapV3LiquidityProvisionMint(client, request, options) {
+  return new APIPromise($do61(client, request, options));
+}
+async function $do61(client, request, options) {
+  const parsed = safeParse(request, (value) => UniswapMintLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v0/uniswap/liquidity_provision/mint")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "uniswap_liquidity_provision_mint",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, TxResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_uniswapV3LiquidityProvisionMint = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_async();
+});
+
+// src/mcp-server/tools/uniswapV3LiquidityProvisionMint.ts
+var args61, tool$uniswapV3LiquidityProvisionMint;
+var init_uniswapV3LiquidityProvisionMint2 = __esm(() => {
+  init_uniswapV3LiquidityProvisionMint();
+  init_components();
+  init_tools();
+  args61 = {
+    request: UniswapMintLiquidityProvisionRequest$inboundSchema
+  };
+  tool$uniswapV3LiquidityProvisionMint = {
+    name: "uniswap-v3-liquidity-provision-mint",
+    description: `Open a new LP position
+
+This endpoint allows users to open a new Liquidity Provider (LP) position on the
+Uniswap platform.
+
+By providing the necessary parameters, users can initiate a minting process to
+create a new LP token, which represents their stake in a specific liquidity pool.
+This operation is essential for users looking to participate in liquidity provision,
+enabling them to earn fees from trades that occur within the pool. The endpoint
+requires details such as the token pair, amount, and any additional parameters
+needed for the minting process.`,
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionMint(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/uniswapV3LiquidityProvisionPositions.ts
+function uniswapV3LiquidityProvisionPositions(client, request, options) {
+  return new APIPromise($do62(client, request, options));
+}
+async function $do62(client, request, options) {
+  const parsed = safeParse(request, (value) => UniswapLiquidityProvisionPositionsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/v0/uniswap/liquidity_provision/positions/get")();
+  const query = encodeFormQuery({
+    chain: payload.chain,
+    user: payload.user
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "uniswap_liquidity_provision_positions",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, UniswapLPPositionsInfoResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_uniswapV3LiquidityProvisionPositions = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/uniswapV3LiquidityProvisionPositions.ts
+var args62, tool$uniswapV3LiquidityProvisionPositions;
+var init_uniswapV3LiquidityProvisionPositions2 = __esm(() => {
+  init_uniswapV3LiquidityProvisionPositions();
+  init_operations();
+  init_tools();
+  args62 = {
     request: UniswapLiquidityProvisionPositionsRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionPositions = {
@@ -51399,9 +51880,9 @@ Users can query this endpoint to obtain detailed information about their LP
 positions, including the total number of positions and relevant metadata. This
 information is crucial for users to manage and analyze their liquidity provision
 activities effectively.`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionPositions(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionPositions(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51416,9 +51897,9 @@ activities effectively.`,
 
 // src/funcs/uniswapV3LiquidityProvisionWithdraw.ts
 function uniswapV3LiquidityProvisionWithdraw(client, request, options) {
-  return new APIPromise($do60(client, request, options));
+  return new APIPromise($do63(client, request, options));
 }
-async function $do60(client, request, options) {
+async function $do63(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapWithdrawLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51489,12 +51970,12 @@ var init_uniswapV3LiquidityProvisionWithdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3LiquidityProvisionWithdraw.ts
-var args60, tool$uniswapV3LiquidityProvisionWithdraw;
+var args63, tool$uniswapV3LiquidityProvisionWithdraw;
 var init_uniswapV3LiquidityProvisionWithdraw2 = __esm(() => {
   init_uniswapV3LiquidityProvisionWithdraw();
   init_components();
   init_tools();
-  args60 = {
+  args63 = {
     request: UniswapWithdrawLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionWithdraw = {
@@ -51511,9 +51992,9 @@ pools or investments. The endpoint requires details such as the token pair, the
 amount to be withdrawn, and any additional parameters needed for the withdrawal
 process. Users should ensure they meet any protocol requirements or conditions
 before initiating a withdrawal to avoid potential issues or penalties.`,
-    args: args60,
-    tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionWithdraw(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionWithdraw(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51528,9 +52009,9 @@ before initiating a withdrawal to avoid potential issues or penalties.`,
 
 // src/funcs/uniswapV3PoolPrice.ts
 function uniswapV3PoolPrice(client, request, options) {
-  return new APIPromise($do61(client, request, options));
+  return new APIPromise($do64(client, request, options));
 }
-async function $do61(client, request, options) {
+async function $do64(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapPoolPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51608,12 +52089,12 @@ var init_uniswapV3PoolPrice = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3PoolPrice.ts
-var args61, tool$uniswapV3PoolPrice;
+var args64, tool$uniswapV3PoolPrice;
 var init_uniswapV3PoolPrice2 = __esm(() => {
   init_uniswapV3PoolPrice();
   init_operations();
   init_tools();
-  args61 = {
+  args64 = {
     request: UniswapPoolPriceRequest$inboundSchema
   };
   tool$uniswapV3PoolPrice = {
@@ -51623,9 +52104,9 @@ var init_uniswapV3PoolPrice2 = __esm(() => {
 This endpoint calculates the price of a token in a Uniswap pool.
 
 The price is calculated based on the current pool state and the specified fee tier.`,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await uniswapV3PoolPrice(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await uniswapV3PoolPrice(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51640,9 +52121,9 @@ The price is calculated based on the current pool state and the specified fee ti
 
 // src/funcs/uniswapV3QuoteBuyExactly.ts
 function uniswapV3QuoteBuyExactly(client, request, options) {
-  return new APIPromise($do62(client, request, options));
+  return new APIPromise($do65(client, request, options));
 }
-async function $do62(client, request, options) {
+async function $do65(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapQuoteBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51721,12 +52202,12 @@ var init_uniswapV3QuoteBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3QuoteBuyExactly.ts
-var args62, tool$uniswapV3QuoteBuyExactly;
+var args65, tool$uniswapV3QuoteBuyExactly;
 var init_uniswapV3QuoteBuyExactly2 = __esm(() => {
   init_uniswapV3QuoteBuyExactly();
   init_operations();
   init_tools();
-  args62 = {
+  args65 = {
     request: UniswapQuoteBuyExactlyRequest$inboundSchema
   };
   tool$uniswapV3QuoteBuyExactly = {
@@ -51738,9 +52219,9 @@ specified amount of output tokens from a Uniswap pool.
 
 It also provides the resulting price after the transaction. The calculation takes
 into account the current pool state and the specified fee tier.`,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await uniswapV3QuoteBuyExactly(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await uniswapV3QuoteBuyExactly(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51755,9 +52236,9 @@ into account the current pool state and the specified fee tier.`,
 
 // src/funcs/uniswapV3QuoteSellExactly.ts
 function uniswapV3QuoteSellExactly(client, request, options) {
-  return new APIPromise($do63(client, request, options));
+  return new APIPromise($do66(client, request, options));
 }
-async function $do63(client, request, options) {
+async function $do66(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapQuoteSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51836,12 +52317,12 @@ var init_uniswapV3QuoteSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3QuoteSellExactly.ts
-var args63, tool$uniswapV3QuoteSellExactly;
+var args66, tool$uniswapV3QuoteSellExactly;
 var init_uniswapV3QuoteSellExactly2 = __esm(() => {
   init_uniswapV3QuoteSellExactly();
   init_operations();
   init_tools();
-  args63 = {
+  args66 = {
     request: UniswapQuoteSellExactlyRequest$inboundSchema
   };
   tool$uniswapV3QuoteSellExactly = {
@@ -51853,9 +52334,9 @@ specified amount of output tokens from a Uniswap pool.
 
 It also provides the resulting price after the transaction. The calculation takes
 into account the current pool state and the specified fee tier.`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await uniswapV3QuoteSellExactly(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await uniswapV3QuoteSellExactly(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51870,9 +52351,9 @@ into account the current pool state and the specified fee tier.`,
 
 // src/funcs/uniswapV3SwapBuyExactly.ts
 function uniswapV3SwapBuyExactly(client, request, options) {
-  return new APIPromise($do64(client, request, options));
+  return new APIPromise($do67(client, request, options));
 }
-async function $do64(client, request, options) {
+async function $do67(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51943,12 +52424,12 @@ var init_uniswapV3SwapBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3SwapBuyExactly.ts
-var args64, tool$uniswapV3SwapBuyExactly;
+var args67, tool$uniswapV3SwapBuyExactly;
 var init_uniswapV3SwapBuyExactly2 = __esm(() => {
   init_uniswapV3SwapBuyExactly();
   init_components();
   init_tools();
-  args64 = {
+  args67 = {
     request: UniswapBuyExactlyRequest$inboundSchema
   };
   tool$uniswapV3SwapBuyExactly = {
@@ -51962,9 +52443,9 @@ The transaction is executed on the specified blockchain network, and the user mu
 provide the necessary transaction details, including the token to buy, the token to
 pay with, and the exact amount to receive. If the token being paid with is WETH and
 needs to be wrapped, the appropriate amount will be wrapped automatically.`,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await uniswapV3SwapBuyExactly(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await uniswapV3SwapBuyExactly(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51979,9 +52460,9 @@ needs to be wrapped, the appropriate amount will be wrapped automatically.`,
 
 // src/funcs/uniswapV3SwapSellExactly.ts
 function uniswapV3SwapSellExactly(client, request, options) {
-  return new APIPromise($do65(client, request, options));
+  return new APIPromise($do68(client, request, options));
 }
-async function $do65(client, request, options) {
+async function $do68(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52052,12 +52533,12 @@ var init_uniswapV3SwapSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3SwapSellExactly.ts
-var args65, tool$uniswapV3SwapSellExactly;
+var args68, tool$uniswapV3SwapSellExactly;
 var init_uniswapV3SwapSellExactly2 = __esm(() => {
   init_uniswapV3SwapSellExactly();
   init_components();
   init_tools();
-  args65 = {
+  args68 = {
     request: UniswapSellExactlyRequest$inboundSchema
   };
   tool$uniswapV3SwapSellExactly = {
@@ -52071,9 +52552,9 @@ The transaction is executed on the specified blockchain network, and the user mu
 provide the necessary transaction details, including the token to sell, the token to
 receive, and the amount to sell. If the token being sold is WETH and needs to be
 wrapped, the appropriate amount will be wrapped automatically.`,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await uniswapV3SwapSellExactly(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await uniswapV3SwapSellExactly(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52088,9 +52569,9 @@ wrapped, the appropriate amount will be wrapped automatically.`,
 
 // src/funcs/universalAllowance.ts
 function universalAllowance(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do69(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do69(client, request, options) {
   const parsed = safeParse(request, (value) => GenericAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52168,12 +52649,12 @@ var init_universalAllowance = __esm(() => {
 });
 
 // src/mcp-server/tools/universalAllowance.ts
-var args66, tool$universalAllowance;
+var args69, tool$universalAllowance;
 var init_universalAllowance2 = __esm(() => {
   init_universalAllowance();
   init_operations();
   init_tools();
-  args66 = {
+  args69 = {
     request: GenericAllowanceRequest$inboundSchema
   };
   tool$universalAllowance = {
@@ -52187,9 +52668,9 @@ tokens on their behalf.
 This is a crucial step before engaging in any transactions or operations within
 these protocols, ensuring that the protocol has the necessary permissions to manage
 the user's tokens securely and efficiently.`,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await universalAllowance(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await universalAllowance(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52204,9 +52685,9 @@ the user's tokens securely and efficiently.`,
 
 // src/funcs/universalAllowanceSet.ts
 function universalAllowanceSet(client, request, options) {
-  return new APIPromise($do67(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do67(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse(request, (value) => IncreaseAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52277,12 +52758,12 @@ var init_universalAllowanceSet = __esm(() => {
 });
 
 // src/mcp-server/tools/universalAllowanceSet.ts
-var args67, tool$universalAllowanceSet;
+var args70, tool$universalAllowanceSet;
 var init_universalAllowanceSet2 = __esm(() => {
   init_universalAllowanceSet();
   init_components();
   init_tools();
-  args67 = {
+  args70 = {
     request: IncreaseAllowanceRequest$inboundSchema
   };
   tool$universalAllowanceSet = {
@@ -52297,9 +52778,9 @@ authorize a protocol to spend a specified amount of tokens on behalf of the user
 This operation is crucial for ensuring that the protocol can manage the user's
 tokens securely and efficiently, enabling seamless transactions and operations
 within the DeFi ecosystem.`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await universalAllowanceSet(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await universalAllowanceSet(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52314,9 +52795,9 @@ within the DeFi ecosystem.`,
 
 // src/funcs/universalEns.ts
 function universalEns(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse(request, (value) => GenericEnsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52392,12 +52873,12 @@ var init_universalEns = __esm(() => {
 });
 
 // src/mcp-server/tools/universalEns.ts
-var args68, tool$universalEns;
+var args71, tool$universalEns;
 var init_universalEns2 = __esm(() => {
   init_universalEns();
   init_operations();
   init_tools();
-  args68 = {
+  args71 = {
     request: GenericEnsRequest$inboundSchema
   };
   tool$universalEns = {
@@ -52408,9 +52889,9 @@ An ENS name is a string ending in \`.eth\`.
 
 E.g. \`vitalik.eth\`. This endpoint can be used to
 query the actual ethereum wallet address behind the ENS name.`,
-    args: args68,
-    tool: async (client, args69, ctx) => {
-      const [result, apiCall] = await universalEns(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await universalEns(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52425,9 +52906,9 @@ query the actual ethereum wallet address behind the ENS name.`,
 
 // src/funcs/universalPortfolio.ts
 function universalPortfolio(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse(request, (value) => GenericPortfolioRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52503,12 +52984,12 @@ var init_universalPortfolio = __esm(() => {
 });
 
 // src/mcp-server/tools/universalPortfolio.ts
-var args69, tool$universalPortfolio;
+var args72, tool$universalPortfolio;
 var init_universalPortfolio2 = __esm(() => {
   init_universalPortfolio();
   init_operations();
   init_tools();
-  args69 = {
+  args72 = {
     request: GenericPortfolioRequest$inboundSchema
   };
   tool$universalPortfolio = {
@@ -52519,9 +53000,9 @@ Fetch the detailed portfolio of a specific wallet address on a given blockchain.
 
 This includes the total value of the portfolio in USD and a breakdown of token
 balances, including their respective values and quantities.`,
-    args: args69,
-    tool: async (client, args70, ctx) => {
-      const [result, apiCall] = await universalPortfolio(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await universalPortfolio(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52536,9 +53017,9 @@ balances, including their respective values and quantities.`,
 
 // src/funcs/universalSupportedTokens.ts
 function universalSupportedTokens(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse(request, (value) => GenericSupportedTokensRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52613,12 +53094,12 @@ var init_universalSupportedTokens = __esm(() => {
 });
 
 // src/mcp-server/tools/universalSupportedTokens.ts
-var args70, tool$universalSupportedTokens;
+var args73, tool$universalSupportedTokens;
 var init_universalSupportedTokens2 = __esm(() => {
   init_universalSupportedTokens();
   init_operations();
   init_tools();
-  args70 = {
+  args73 = {
     request: GenericSupportedTokensRequest$inboundSchema
   };
   tool$universalSupportedTokens = {
@@ -52626,9 +53107,9 @@ var init_universalSupportedTokens2 = __esm(() => {
     description: `List supported tokens
 
 Get the list of supported tokens on a chain by the Compass API.`,
-    args: args70,
-    tool: async (client, args71, ctx) => {
-      const [result, apiCall] = await universalSupportedTokens(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await universalSupportedTokens(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52643,9 +53124,9 @@ Get the list of supported tokens on a chain by the Compass API.`,
 
 // src/funcs/universalUnwrapWeth.ts
 function universalUnwrapWeth(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse(request, (value) => UnwrapWethRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52716,12 +53197,12 @@ var init_universalUnwrapWeth = __esm(() => {
 });
 
 // src/mcp-server/tools/universalUnwrapWeth.ts
-var args71, tool$universalUnwrapWeth;
+var args74, tool$universalUnwrapWeth;
 var init_universalUnwrapWeth2 = __esm(() => {
   init_universalUnwrapWeth();
   init_components();
   init_tools();
-  args71 = {
+  args74 = {
     request: UnwrapWethRequest$inboundSchema
   };
   tool$universalUnwrapWeth = {
@@ -52730,9 +53211,9 @@ var init_universalUnwrapWeth2 = __esm(() => {
 
 Unwrapping WETH converts the ERC-20 compliant form of ETH back to native ETH that
 can be used for gas and other native purposes.`,
-    args: args71,
-    tool: async (client, args72, ctx) => {
-      const [result, apiCall] = await universalUnwrapWeth(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await universalUnwrapWeth(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52747,9 +53228,9 @@ can be used for gas and other native purposes.`,
 
 // src/funcs/universalVisualizePortfolio.ts
 function universalVisualizePortfolio(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse(request, (value) => GenericVisualizePortfolioRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52825,12 +53306,12 @@ var init_universalVisualizePortfolio = __esm(() => {
 });
 
 // src/mcp-server/tools/universalVisualizePortfolio.ts
-var args72, tool$universalVisualizePortfolio;
+var args75, tool$universalVisualizePortfolio;
 var init_universalVisualizePortfolio2 = __esm(() => {
   init_universalVisualizePortfolio();
   init_operations();
   init_tools();
-  args72 = {
+  args75 = {
     request: GenericVisualizePortfolioRequest$inboundSchema
   };
   tool$universalVisualizePortfolio = {
@@ -52842,9 +53323,9 @@ Generate a visual representation of the token portfolio for a wallet address.
 The response is an SVG image of a pie chart depicting the relative distribution of
 tokens held, colored and labeled with token symbols, percentages and token values in
 USD.`,
-    args: args72,
-    tool: async (client, args73, ctx) => {
-      const [result, apiCall] = await universalVisualizePortfolio(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await universalVisualizePortfolio(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52859,9 +53340,9 @@ USD.`,
 
 // src/funcs/universalWrapEth.ts
 function universalWrapEth(client, request, options) {
-  return new APIPromise($do73(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse(request, (value) => WrapEthRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52932,12 +53413,12 @@ var init_universalWrapEth = __esm(() => {
 });
 
 // src/mcp-server/tools/universalWrapEth.ts
-var args73, tool$universalWrapEth;
+var args76, tool$universalWrapEth;
 var init_universalWrapEth2 = __esm(() => {
   init_universalWrapEth();
   init_components();
   init_tools();
-  args73 = {
+  args76 = {
     request: WrapEthRequest$inboundSchema
   };
   tool$universalWrapEth = {
@@ -52946,9 +53427,9 @@ var init_universalWrapEth2 = __esm(() => {
 
 Wrapping ETH creates an ERC20 compliant form of ETH that is typically needed for
 it to be traded on DeFi protocols.`,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await universalWrapEth(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await universalWrapEth(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52965,7 +53446,7 @@ it to be traded on DeFi protocols.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "CompassApiSDK",
-    version: "0.5.13"
+    version: "0.5.14"
   });
   const client = new CompassApiSDKCore({
     apiKeyAuth: deps.apiKeyAuth,
@@ -53051,6 +53532,9 @@ function createMCPServer(deps) {
   tool(tool$pendleRedeemYield);
   tool(tool$pendleAddLiquidity);
   tool(tool$pendleRemoveLiquidity);
+  tool(tool$transactionBatchingAuthorization);
+  tool(tool$transactionBatchingExecute);
+  tool(tool$transactionBatchingAaveLoop);
   tool(tool$smartAccountAccountBatchedUserOperations);
   return server;
 }
@@ -53114,6 +53598,9 @@ var init_server2 = __esm(() => {
   init_tokenBalance2();
   init_tokenPrice2();
   init_tokenTransfer2();
+  init_transactionBatchingAaveLoop2();
+  init_transactionBatchingAuthorization2();
+  init_transactionBatchingExecute2();
   init_uniswapV3LiquidityProvisionIncrease2();
   init_uniswapV3LiquidityProvisionInRange2();
   init_uniswapV3LiquidityProvisionMint2();
@@ -54322,7 +54809,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.5.13"
+    currentVersion: "0.5.14"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -54330,5 +54817,5 @@ export {
   app
 };
 
-//# debugId=A09AEF55DB6A972464756E2164756E21
+//# debugId=15D9FD6FAC35FAB164756E2164756E21
 //# sourceMappingURL=mcp-server.js.map