matter-labs · jodator · Feb 16, 2026 · Feb 16, 2026 · Feb 16, 2026 · Feb 17, 2026
@@ -18,6 +18,7 @@ import { ForbiddenException } from "@nestjs/common";
 import { Wallet, zeroPadValue } from "ethers";
 import { UserWithRoles } from "../api/pipes/addUserRoles.pipe";
 import { ConfigService } from "@nestjs/config";
+import { BASE_TOKEN_L2_ADDRESS } from "../common/constants";
 
 jest.mock("../common/utils", () => ({
   ...jest.requireActual("../common/utils"),
@@ -278,6 +279,11 @@ describe("AddressController", () => {
         await expect(controller.getAddress(blockchainAddress, user)).rejects.toThrow(ForbiddenException);
       });
 
+      it("does not throw if address is the base token address", async () => {
+        serviceMock.findOne.mockResolvedValue(null);
+        await expect(controller.getAddress(BASE_TOKEN_L2_ADDRESS, user)).resolves.toBeDefined();
+      });
+
       describe("when address is a contract", () => {
         beforeEach(() => {
           serviceMock.findOne.mockResolvedValue(mock<Address>({ address: blockchainAddress, bytecode: "0x123" }));

@@ -25,6 +25,7 @@ import { TransferService } from "../transfer/transfer.service";
 import { TransferDto } from "../transfer/transfer.dto";
 import { swagger } from "../config/featureFlags";
 import { constants } from "../config/docs";
+import { BASE_TOKEN_L2_ADDRESS } from "../common/constants";
 import { User } from "../user/user.decorator";
 import { AddUserRolesPipe, UserWithRoles } from "../api/pipes/addUserRoles.pipe";
 
@@ -70,14 +71,17 @@ export class AddressController {
     const addressType = !!(addressRecord && addressRecord.bytecode.length > 2)
       ? AddressType.Contract
       : AddressType.Account;
+
+    const isPublicBaseTokenAddress = isAddressEqual(address, BASE_TOKEN_L2_ADDRESS);
+
     let includeBalances = true;
     let includeBytecode = true;
     let includeCreatorAddress = true;
     let includeCreatorTxHash = true;
 
     if (user && !user.isAdmin) {
       // If address is an account and is not own address, forbid access
-      if (addressType === AddressType.Account && !isAddressEqual(user.address, address)) {
+      if (addressType === AddressType.Account && !isAddressEqual(user.address, address) && !isPublicBaseTokenAddress) {
         throw new ForbiddenException();
       }
 

@@ -54,9 +54,10 @@
         </TransactionsTable>
       </template>
       <template #tab-2-content>
-        <ContractInfoTab :contract="contract" />
+        <TransfersTable v-if="isBaseToken" :address="contract.address" :for-token="true" />
+        <ContractInfoTab v-if="!isBaseToken" :contract="contract" />
       </template>
-      <template #tab-3-content>
+      <template v-if="!isBaseToken" #tab-3-content>
         <ContractEvents v-if="showEventsTab" :contract="contract" />
       </template>
     </Tabs>
@@ -79,6 +80,7 @@ import ContractEvents from "@/components/event/ContractEvents.vue";
 import MarketTokenInfoTable from "@/components/token/MarketTokenInfoTable.vue";
 import OverviewTokenInfoTable from "@/components/token/OverviewTokenInfoTable.vue";
 import TransactionsTable from "@/components/transactions/Table.vue";
+import TransfersTable from "@/components/transfers/Table.vue";
 
 import useContext from "@/composables/useContext";
 import useRuntimeConfig from "@/composables/useRuntimeConfig";
@@ -112,6 +114,10 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
+  isBaseToken: {
+    type: Boolean,
+    default: false,
+  },
 });
 
 const { getTokenInfo, tokenInfo } = useToken();
@@ -126,12 +132,16 @@ watchEffect(() => {
 
 const tabs = computed(() => [
   { title: t("tabs.transactions"), hash: "#transactions" },
-  {
-    title: t("tabs.contract"),
-    hash: "#contract",
-    icon: props.contract?.verificationInfo ? CheckCircleIcon : null,
-  },
-  { title: t("tabs.events"), hash: showEventsTab.value ? "#events" : null },
+  ...(props.isBaseToken
+    ? [{ title: t("tabs.transfers"), hash: "#transfers" }]
+    : [
+        {
+          title: t("tabs.contract"),
+          hash: "#contract",
+          icon: props.contract?.verificationInfo ? CheckCircleIcon : null,
+        },
+        { title: t("tabs.events"), hash: showEventsTab.value ? "#events" : null },
+      ]),
 ]);
 
 const breadcrumbItems = computed((): BreadcrumbItem[] | [] => {

@@ -90,6 +90,7 @@
 
       <TableBodyColumn :data-heading="t('transfers.table.direction')">
         <TransactionDirectionTableCell
+          v-if="!forToken"
           :data-testid="$testId.direction"
           class="transfers-in-out"
           :text="getTransferDirection(item)"
@@ -167,12 +168,17 @@ const props = defineProps({
     required: true,
     default: () => null,
   },
+  forToken: {
+    type: Boolean,
+    default: false,
+  },
 });
 
 const { data, load, total, pending, pageSize } = useTransfers(
   computed(() => {
     return props.address;
-  })
+  }),
+  { forToken: props.forToken }
 );
 
 function getTransferDirection(item: Transfer): Direction {
@@ -185,7 +191,7 @@ const toDate = new Date();
 watch(
   [activePage, () => props.address],
   ([page]) => {
-    load(page, toDate);
+    load(page, props.forToken ? undefined : toDate);
   },
   { immediate: true }
 );

@@ -6,23 +6,30 @@ import { FetchError } from "ohmyfetch";
 import useContext from "./useContext";
 import { FetchInstance } from "./useFetchInstance";
 
-import { isAddress, isBlockNumber, isTransactionHash } from "@/utils/validators";
+import { isAddress, isAddressEqual, isBlockNumber, isTransactionHash } from "@/utils/validators";
 
 export default (context = useContext()) => {
   const router = useRouter();
   const isRequestPending = ref(false);
   const isRequestFailed = ref(false);
 
+  const isPrividiumBaseTokenAddress = (address: string) =>
+    !!context.currentNetwork.value.prividium && isAddressEqual(address, context.currentNetwork.value.baseTokenAddress);
+
   const getSearchRoute = (param: string) => {
     try {
-      const searchRoutes = [
-        {
+      if (isAddress(param)) {
+        const isBaseTokenAddress = isPrividiumBaseTokenAddress(param);
+        return {
           routeParam: { address: param },
           apiRoute: "address",
-          isValid: () => isAddress(param),
-          routeName: "address",
+          isValid: () => true,
+          routeName: isBaseTokenAddress ? "token" : "address",
           prefetch: true,
-        },
+        };
+      }
+
+      const searchRoutes = [
         {
           routeParam: { id: param },
           apiRoute: "blocks",

@@ -9,13 +9,22 @@ export type Transfer = Api.Response.Transfer & {
   toNetwork: NetworkOrigin;
 };
 
-export default (address: ComputedRef<string>, context = useContext()) => {
+interface UseTransferOptions {
+  forToken?: boolean;
+}
+
+export default (
+  address: ComputedRef<string>,
+  { forToken = false }: UseTransferOptions = {},
+  context = useContext()
+) => {
   return useFetchCollection<Transfer, Api.Response.Transfer>(
-    () =>
-      new URL(
-        `/address/${address.value}/transfers?toDate=${new Date().toISOString()}`,
-        context.currentNetwork.value.apiUrl
-      ),
+    () => {
+      const path = forToken
+        ? `/tokens/${address.value}/transfers`
+        : `/address/${address.value}/transfers?toDate=${new Date().toISOString()}`;
+      return new URL(path, context.currentNetwork.value.apiUrl);
+    },
     (transfer: Api.Response.Transfer): Transfer => ({
       ...transfer,
       token: transfer.token || {

@@ -1,11 +1,23 @@
-import { AbiCoder, isAddress as ethersIsAddress } from "ethers";
+import { AbiCoder, isAddress as ethersIsAddress, getAddress } from "ethers";
 
 const defaultAbiCoder: AbiCoder = AbiCoder.defaultAbiCoder();
 
 export function isAddress(address: string): boolean {
   return ethersIsAddress(address?.toLowerCase());
 }
 
+export function isAddressEqual(address1?: string | null, address2?: string | null): boolean {
+  if (!address1 || !address2) {
+    return false;
+  }
+
+  try {
+    return getAddress(address1) === getAddress(address2);
+  } catch {
+    return false;
+  }
+}
+
 export const isTransactionHash = (s: string) => {
   return /^0x([A-Fa-f0-9]{64})$/.test(s);
 };

@@ -3,8 +3,14 @@
     <PageError />
   </div>
   <template v-else-if="props.address && isAddress(props.address)">
-    <AccountView v-if="pageType === 'account'" :account="(item as Account)" :pending="pending" :failed="failed" />
-    <TokenView v-else :contract="(item as Contract)" :pending="pending" :failed="failed" />
+    <AccountView v-if="!showTokenComponent" :account="(item as Account)" :pending="pending" :failed="failed" />
+    <TokenView
+      v-else
+      :contract="tokenContract"
+      :pending="pending"
+      :failed="failed"
+      :is-base-token="isPrividiumBaseTokenAddress"
+    />
   </template>
 </template>
 
@@ -16,11 +22,13 @@ import PageError from "@/components/PageError.vue";
 import TokenView from "@/components/Token.vue";
 
 import useAddress, { type Account, type Contract } from "@/composables/useAddress";
+import useContext from "@/composables/useContext";
 import useNotFound from "@/composables/useNotFound";
 
-import { isAddress } from "@/utils/validators";
+import { isAddress, isAddressEqual } from "@/utils/validators";
 
 const { useNotFoundView, setNotFoundView } = useNotFound();
+const { currentNetwork } = useContext();
 
 const { item, isRequestPending: pending, isRequestFailed: failed, getByAddress } = useAddress();
 
@@ -35,6 +43,42 @@ const pageType = computed(() => {
   return item.value?.type ? item.value?.type : "account";
 });
 
+const isPrividiumBaseTokenAddress = computed(() => {
+  const baseTokenAddress = currentNetwork.value.baseTokenAddress;
+  return currentNetwork.value.prividium && isAddressEqual(props.address, baseTokenAddress);
+});
+
+const showTokenComponent = computed(() => pageType.value !== "account" || isPrividiumBaseTokenAddress.value);
+
+const tokenContract = computed<Contract | null>(() => {
+  if (!item.value) {
+    return null;
+  }
+
+  if (item.value.type === "contract") {
+    return item.value as Contract;
+  }
+
+  if (isPrividiumBaseTokenAddress.value) {
+    return {
+      type: "contract",
+      address: item.value.address,
+      blockNumber: item.value.blockNumber,
+      balances: item.value.balances,
+      bytecode: "",
+      creatorAddress: "",
+      creatorTxHash: "",
+      createdInBlockNumber: 0,
+      totalTransactions: 0,
+      isEvmLike: true,
+      verificationInfo: null,
+      proxyInfo: null,
+    };
+  }
+
+  return null;
+});
+
 useNotFoundView(pending, failed, item);
 
 watchEffect(() => {

@@ -1,3 +1,5 @@
+import { computed, ref } from "vue";
+
 import { describe, expect, it, vi } from "vitest";
 
 import { $fetch } from "ohmyfetch";
@@ -72,6 +74,24 @@ describe("UseSearch:", () => {
       const searchRoute = getSearchRoute("123");
       expect(searchRoute).toBeNull();
     });
+
+    it("routes base token address to token page in prividium mode", () => {
+      const { getSearchRoute } = useSearch({
+        currentNetwork: computed(() => ({
+          prividium: true,
+          baseTokenAddress: "0x000000000000000000000000000000000000800A",
+          apiUrl: "http://localhost:3020",
+        })),
+        user: ref({ loggedIn: false }),
+      } as never);
+
+      const searchRoute = getSearchRoute("0x000000000000000000000000000000000000800A");
+      expect(searchRoute!.apiRoute).toBe("address");
+      expect(searchRoute!.routeName).toBe("token");
+      expect(searchRoute!.routeParam).toEqual({
+        address: "0x000000000000000000000000000000000000800A",
+      });
+    });
   });
 
   describe("search", () => {

@@ -157,4 +157,13 @@ describe("useTransfers:", () => {
     expect(composable.data.value).toEqual(null);
     mock.mockRestore();
   });
+
+  it("requests token transfers endpoint when token mode is enabled", async () => {
+    const composable = useTransfers(address, { forToken: true });
+    await composable.load(1);
+
+    expect($fetch).toHaveBeenCalledWith(
+      "https://block-explorer-api.testnets.zksync.dev/tokens/address/transfers?limit=10&page=1"
+    );
+  });
 });