diff --git a/browser/brave_wallet/cardano_provider_renderer_browsertest.cc b/browser/brave_wallet/cardano_provider_renderer_browsertest.cc
index 6d580e49d901..66c8934b91de 100644
--- a/browser/brave_wallet/cardano_provider_renderer_browsertest.cc
+++ b/browser/brave_wallet/cardano_provider_renderer_browsertest.cc
@@ -794,67 +794,206 @@ IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetRewardAddresses_Error) {
 }
 
 IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos) {
-  TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
-      web_contents(browser())->GetPrimaryMainFrame());
-  auto cardano_api = std::make_unique<TestCardanoApi>();
-  ON_CALL(*provider, Enable(_, _))
-      .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
-                         TestCardanoProvider::EnableCallback callback) {
-        cardano_api->BindReceiver(std::move(receiver));
-        std::move(callback).Run(nullptr);
-      });
-  ON_CALL(*cardano_api, GetUtxos(_, _, _))
-      .WillByDefault([&](const std::optional<std::string>& amount,
-                         mojom::CardanoProviderPaginationPtr paginate,
-                         TestCardanoApi::GetUtxosCallback callback) {
-        EXPECT_EQ("1", amount.value());
-        EXPECT_EQ(2, paginate->page);
-        EXPECT_EQ(3, paginate->limit);
-        std::move(callback).Run(std::vector<std::string>({"1", "2"}), nullptr);
-      });
+  // Amount and pagination are defined.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          EXPECT_EQ("1", amount.value());
+          EXPECT_EQ(2, paginate->page);
+          EXPECT_EQ(3, paginate->limit);
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
 
-  auto result = EvalJs(web_contents(browser()),
-                       "(async () => { return await (await "
-                       "window.cardano.brave.enable()).getUtxos(\"1\", {page: "
-                       "2, limit:3}) })();");
+    auto result =
+        EvalJs(web_contents(browser()),
+               "(async () => { return await (await "
+               "window.cardano.brave.enable()).getUtxos(\"1\", {page: "
+               "2, limit:3}) })();");
 
-  base::Value::List list_value;
-  list_value.Append(base::Value("1"));
-  list_value.Append(base::Value("2"));
-  EXPECT_EQ(list_value, result);
-}
+    base::Value::List list_value;
+    list_value.Append(base::Value("1"));
+    list_value.Append(base::Value("2"));
+    EXPECT_EQ(list_value, result);
+  }
 
-IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_NoArgs) {
-  TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
-      web_contents(browser())->GetPrimaryMainFrame());
-  auto cardano_api = std::make_unique<TestCardanoApi>();
-  ON_CALL(*provider, Enable(_, _))
-      .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
-                         TestCardanoProvider::EnableCallback callback) {
-        cardano_api->BindReceiver(std::move(receiver));
-        std::move(callback).Run(nullptr);
-      });
-  ON_CALL(*cardano_api, GetUtxos(_, _, _))
-      .WillByDefault([&](const std::optional<std::string>& amount,
-                         mojom::CardanoProviderPaginationPtr paginate,
-                         TestCardanoApi::GetUtxosCallback callback) {
-        EXPECT_FALSE(amount);
-        EXPECT_FALSE(paginate);
-        std::move(callback).Run(std::vector<std::string>({"1", "2"}), nullptr);
-      });
+  // Amount undefined, pagination not defined.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          EXPECT_FALSE(amount);
+          EXPECT_FALSE(paginate);
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
 
-  auto result = EvalJs(web_contents(browser()),
-                       "(async () => { return await (await "
-                       "window.cardano.brave.enable()).getUtxos() })();");
+    auto result =
+        EvalJs(web_contents(browser()),
+               "(async () => { return await (await "
+               "window.cardano.brave.enable()).getUtxos(undefined) })();");
 
-  base::Value::List list_value;
-  list_value.Append(base::Value("1"));
-  list_value.Append(base::Value("2"));
+    base::Value::List list_value;
+    list_value.Append(base::Value("1"));
+    list_value.Append(base::Value("2"));
+    EXPECT_EQ(list_value, result);
+  }
 
-  EXPECT_EQ(list_value, result);
+  // Amount undefined with defined pagination.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          EXPECT_FALSE(amount);
+          EXPECT_EQ(2, paginate->page);
+          EXPECT_EQ(3, paginate->limit);
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
+
+    auto result =
+        EvalJs(web_contents(browser()),
+               "(async () => { return await (await "
+               "window.cardano.brave.enable()).getUtxos(undefined, {page: "
+               "2, limit:3}) })();");
+
+    base::Value::List list_value;
+    list_value.Append(base::Value("1"));
+    list_value.Append(base::Value("2"));
+    EXPECT_EQ(list_value, result);
+  }
+
+  // Both undefined.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          EXPECT_FALSE(amount);
+          EXPECT_FALSE(paginate);
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
+
+    auto result = EvalJs(
+        web_contents(browser()),
+        "(async () => { return await (await "
+        "window.cardano.brave.enable()).getUtxos(undefined, undefined) })();");
+
+    base::Value::List list_value;
+    list_value.Append(base::Value("1"));
+    list_value.Append(base::Value("2"));
+    EXPECT_EQ(list_value, result);
+  }
+
+  // With amount, pagination not defined.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          EXPECT_EQ("1", amount);
+          EXPECT_FALSE(paginate);
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
+
+    auto result =
+        EvalJs(web_contents(browser()),
+               "(async () => { return await (await "
+               "window.cardano.brave.enable()).getUtxos(\"1\") })();");
+
+    base::Value::List list_value;
+    list_value.Append(base::Value("1"));
+    list_value.Append(base::Value("2"));
+
+    EXPECT_EQ(list_value, result);
+  }
+
+  // With amount, pagination is undefined.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          EXPECT_EQ("1", amount);
+          EXPECT_FALSE(paginate);
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
+
+    auto result = EvalJs(
+        web_contents(browser()),
+        "(async () => { return await (await "
+        "window.cardano.brave.enable()).getUtxos(\"1\", undefined) })();");
+
+    base::Value::List list_value;
+    list_value.Append(base::Value("1"));
+    list_value.Append(base::Value("2"));
+
+    EXPECT_EQ(list_value, result);
+  }
 }
 
-IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_NoPagination) {
+IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_NoArgs) {
   TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
       web_contents(browser())->GetPrimaryMainFrame());
   auto cardano_api = std::make_unique<TestCardanoApi>();
@@ -868,14 +1007,14 @@ IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_NoPagination) {
       .WillByDefault([&](const std::optional<std::string>& amount,
                          mojom::CardanoProviderPaginationPtr paginate,
                          TestCardanoApi::GetUtxosCallback callback) {
-        EXPECT_EQ("1", amount);
+        EXPECT_FALSE(amount);
         EXPECT_FALSE(paginate);
         std::move(callback).Run(std::vector<std::string>({"1", "2"}), nullptr);
       });
 
   auto result = EvalJs(web_contents(browser()),
                        "(async () => { return await (await "
-                       "window.cardano.brave.enable()).getUtxos(\"1\") })();");
+                       "window.cardano.brave.enable()).getUtxos() })();");
 
   base::Value::List list_value;
   list_value.Append(base::Value("1"));
@@ -885,27 +1024,60 @@ IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_NoPagination) {
 }
 
 IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_WrongArguments) {
-  TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
-      web_contents(browser())->GetPrimaryMainFrame());
-  auto cardano_api = std::make_unique<TestCardanoApi>();
-  ON_CALL(*provider, Enable(_, _))
-      .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
-                         TestCardanoProvider::EnableCallback callback) {
-        cardano_api->BindReceiver(std::move(receiver));
-        std::move(callback).Run(nullptr);
-      });
-  ON_CALL(*cardano_api, GetUtxos(_, _, _))
-      .WillByDefault([&](const std::optional<std::string>& amount,
-                         mojom::CardanoProviderPaginationPtr paginate,
-                         TestCardanoApi::GetUtxosCallback callback) {
-        std::move(callback).Run(std::vector<std::string>({"1", "2"}), nullptr);
-      });
+  // Wrong argument types.
+  {
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
+
+    {
+      auto result =
+          EvalJs(web_contents(browser()),
+                 "(async () => { return await (await "
+                 "window.cardano.brave.enable()).getUtxos(1, 2) })();");
+      EXPECT_FALSE(result.is_ok());
+    }
+  }
 
+  // Wrong arguments amount.
   {
-    auto result = EvalJs(web_contents(browser()),
-                         "(async () => { return await (await "
-                         "window.cardano.brave.enable()).getUtxos(1, 2) })();");
-    EXPECT_FALSE(result.is_ok());
+    TestCardanoProvider* provider = test_content_browser_client_.GetProvider(
+        web_contents(browser())->GetPrimaryMainFrame());
+    auto cardano_api = std::make_unique<TestCardanoApi>();
+    ON_CALL(*provider, Enable(_, _))
+        .WillByDefault([&](mojo::PendingReceiver<mojom::CardanoApi> receiver,
+                           TestCardanoProvider::EnableCallback callback) {
+          cardano_api->BindReceiver(std::move(receiver));
+          std::move(callback).Run(nullptr);
+        });
+    ON_CALL(*cardano_api, GetUtxos(_, _, _))
+        .WillByDefault([&](const std::optional<std::string>& amount,
+                           mojom::CardanoProviderPaginationPtr paginate,
+                           TestCardanoApi::GetUtxosCallback callback) {
+          std::move(callback).Run(std::vector<std::string>({"1", "2"}),
+                                  nullptr);
+        });
+
+    {
+      auto result = EvalJs(web_contents(browser()),
+                           "(async () => { return await (await "
+                           "window.cardano.brave.enable()).getUtxos(undefined, "
+                           "undefined, undefined) })();");
+      EXPECT_FALSE(result.is_ok());
+    }
   }
 }
 
@@ -937,7 +1109,7 @@ IN_PROC_BROWSER_TEST_F(CardanoProviderRendererTest, GetUtxos_WrongPagination) {
                          "window.cardano.brave.enable()).getUtxos() } "
                          "catch(error) {return error} })();");
     base::Value::Dict dict_value;
-    dict_value.Set("maxNumber", base::Value(2));
+    dict_value.Set("maxSize", base::Value(2));
 
     EXPECT_EQ(dict_value, result);
   }
diff --git a/components/brave_wallet/renderer/js_cardano_wallet_api.cc b/components/brave_wallet/renderer/js_cardano_wallet_api.cc
index 1808ca3b4fbe..2366495092d1 100644
--- a/components/brave_wallet/renderer/js_cardano_wallet_api.cc
+++ b/components/brave_wallet/renderer/js_cardano_wallet_api.cc
@@ -37,7 +37,7 @@ v8::Local<v8::Value> ConvertError(
   base::Value::Dict error_value;
 
   if (error->pagination_error_payload) {
-    error_value.Set("maxNumber",
+    error_value.Set("maxSize",
                     base::Value(error->pagination_error_payload->payload));
     return content::V8ValueConverter::Create()->ToV8Value(error_value, context);
   }
@@ -358,31 +358,35 @@ v8::Local<v8::Promise> JSCardanoWalletApi::GetUtxos(gin::Arguments* args) {
     std::unique_ptr<base::Value> arg1_value =
         content::V8ValueConverter::Create()->FromV8Value(
             arguments.at(0), isolate->GetCurrentContext());
-    if (!arg1_value || !arg1_value->GetIfString()) {
+    if (arg1_value && !arg1_value->is_string()) {
       args->ThrowError();
       return v8::Local<v8::Promise>();
     }
-    amount = arg1_value->GetString();
+    if (arg1_value) {
+      amount = arg1_value->GetString();
+    }
   }
 
   if (arguments.size() > 1) {
     std::unique_ptr<base::Value> arg2_value =
         content::V8ValueConverter::Create()->FromV8Value(
             arguments.at(1), isolate->GetCurrentContext());
-    if (!arg2_value || !arg2_value->GetIfDict()) {
+    if (arg2_value && !arg2_value->is_dict()) {
       args->ThrowError();
       return v8::Local<v8::Promise>();
     }
 
-    auto page_value = arg2_value->GetIfDict()->FindInt("page");
-    auto page_limit = arg2_value->GetIfDict()->FindInt("limit");
+    if (arg2_value) {
+      auto page_value = arg2_value->GetDict().FindInt("page");
+      auto page_limit = arg2_value->GetDict().FindInt("limit");
 
-    if (!page_value || !page_limit) {
-      args->ThrowError();
-      return v8::Local<v8::Promise>();
-    }
+      if (!page_value || !page_limit) {
+        args->ThrowError();
+        return v8::Local<v8::Promise>();
+      }
 
-    page = mojom::CardanoProviderPagination::New(*page_value, *page_limit);
+      page = mojom::CardanoProviderPagination::New(*page_value, *page_limit);
+    }
   }
 
   cardano_api_->GetUtxos(
@@ -421,7 +425,7 @@ v8::Local<v8::Promise> JSCardanoWalletApi::SignTx(gin::Arguments* args) {
       content::V8ValueConverter::Create()->FromV8Value(
           arguments.at(0), isolate->GetCurrentContext());
 
-  if (!arg1_value || !arg1_value->GetIfString()) {
+  if (!arg1_value || !arg1_value->is_string()) {
     args->ThrowError();
     return v8::Local<v8::Promise>();
   }
@@ -432,12 +436,12 @@ v8::Local<v8::Promise> JSCardanoWalletApi::SignTx(gin::Arguments* args) {
         content::V8ValueConverter::Create()->FromV8Value(
             arguments.at(1), isolate->GetCurrentContext());
 
-    if (!arg2_value || !arg2_value->GetIfBool()) {
+    if (!arg2_value || !arg2_value->is_bool()) {
       args->ThrowError();
       return v8::Local<v8::Promise>();
     }
 
-    partial_sign = arg2_value->GetIfBool().value_or(false);
+    partial_sign = arg2_value->GetBool();
   }
 
   cardano_api_->SignTx(
@@ -479,8 +483,8 @@ v8::Local<v8::Promise> JSCardanoWalletApi::SignData(gin::Arguments* args) {
       content::V8ValueConverter::Create()->FromV8Value(
           arguments.at(1), isolate->GetCurrentContext());
 
-  if (!arg1_value || !arg2_value || !arg1_value->GetIfString() ||
-      !arg2_value->GetIfString()) {
+  if (!arg1_value || !arg2_value || !arg1_value->is_string() ||
+      !arg2_value->is_string()) {
     args->ThrowError();
     return v8::Local<v8::Promise>();
   }
@@ -546,7 +550,7 @@ v8::Local<v8::Promise> JSCardanoWalletApi::SubmitTx(gin::Arguments* args) {
   std::unique_ptr<base::Value> arg1_value =
       content::V8ValueConverter::Create()->FromV8Value(
           arguments.at(0), isolate->GetCurrentContext());
-  if (!arg1_value || !arg1_value->GetIfString()) {
+  if (!arg1_value || !arg1_value->is_string()) {
     args->ThrowError();
     return v8::Local<v8::Promise>();
   }
@@ -604,7 +608,7 @@ v8::Local<v8::Promise> JSCardanoWalletApi::GetCollateral(gin::Arguments* args) {
       content::V8ValueConverter::Create()->FromV8Value(
           arguments.at(0), isolate->GetCurrentContext());
 
-  if (!arg1_value || !arg1_value->GetIfDict()) {
+  if (!arg1_value || !arg1_value->is_dict()) {
     args->ThrowError();
     return v8::Local<v8::Promise>();
   }