feat: initial changes to show erc20 as native token in explorer

docker-compose.yaml

@@ -79,15 +79,18 @@ services:
       - POSTGRES_PASSWORD=postgres
       - POSTGRES_DB=block-explorer
 
-  geth:
-    image: "matterlabs/geth:latest"
-    logging:
-      driver: none
-    ports:
-      - "8545:8545"
-      - "8546:8546"
+  reth:
+    restart: always
+    image: "ghcr.io/paradigmxyz/reth:v0.2.0-beta.2"
     volumes:
-      - geth:/var/lib/geth/data
+      - type: bind
+        source: ./reth_chaindata
+        target: /chaindata
+    command: node --dev --datadir /rethdata --http --http.addr 0.0.0.0 --http.port 8545  --dev.block-time 300ms --chain /chaindata/reth_config
+    environment:
+      - RUST_LOG=warn
+    ports:
+      - 127.0.0.1:8545:8545
 
   zksync:
     stdin_open: true
@@ -96,28 +99,30 @@ services:
     depends_on:
       postgres:
         condition: service_healthy
-      geth:
+      reth:
         condition: service_started
     ports:
-      - "3050:3050" # JSON RPC HTTP port
-      - "3051:3051" # JSON RPC WS port
+      - 127.0.0.1:3050:3050 # JSON RPC HTTP port
+      - 127.0.0.1:3051:3051 # JSON RPC WS port
     volumes:
       # Configs folder bind
       - zksync-config:/etc/env/
       # Storage folder bind
       - zksync-data:/var/lib/zksync/data
     environment:
-      - DATABASE_URL=postgres://postgres:postgres@postgres:5432/zksync_local
-      - ETH_CLIENT_WEB3_URL=http://geth:8545
+      - DATABASE_PROVER_URL=postgres://postgres:postgres@postgres/prover_local
+      - DATABASE_URL=postgres://postgres:postgres@postgres/zksync_local
+      - ETH_CLIENT_WEB3_URL=http://reth:8545 
     healthcheck:
-      test: "curl -H \"Content-Type: application/json\" -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"web3_clientVersion\",\"params\":[],\"id\":67}' 127.0.0.1:3050 || exit 1"
-      interval: 5s
+      test: curl --fail http://localhost:3071/health || exit 1
+      interval: 10s
       timeout: 5s
-      retries: 300
+      retries: 60
+      start_period: 30s
     restart: unless-stopped
 
 volumes:
-  geth:
+  reth:
   postgres:
   zksync-config:
   zksync-data:

packages/api/.env.example

@@ -15,3 +15,10 @@ DISABLE_EXTERNAL_API=false
 DATABASE_STATEMENT_TIMEOUT_MS=90000
 CONTRACT_VERIFICATION_API_URL=http://127.0.0.1:3070
 NETWORK_NAME=testnet-sepolia
+BASE_TOKEN_SYMBOL=wETH
+BASE_TOKEN_DECIMALS=18
+BASE_TOKEN_L1_ADDRESS=0x8E9C82509488eD471A83824d20Dd474b8F534a0b
+BASE_TOKEN_ICON_URL=https://assets.coingecko.com/coins/images/279/large/ethereum.png?1698873266
+BASE_TOKEN_NAME=Ether
+BASE_TOKEN_LIQUIDITY=220000000000
+BASE_TOKEN_USDPRICE=1800

packages/api/src/api/account/account.controller.spec.ts

@@ -1,7 +1,7 @@
 import { Test } from "@nestjs/testing";
 import { mock } from "jest-mock-extended";
 import { BadRequestException, Logger } from "@nestjs/common";
-import { L2_ETH_TOKEN_ADDRESS } from "../../common/constants";
+import { BASE_TOKEN_L2_ADDRESS } from "../../common/constants";
 import { BlockService } from "../../block/block.service";
 import { BlockDetails } from "../../block/blockDetails.entity";
 import { TransactionService } from "../../transaction/transaction.service";
@@ -557,7 +557,7 @@ describe("AccountController", () => {
   describe("getAccountEtherBalance", () => {
     it("calls balanceService.getBalance and returns account ether balance", async () => {
       const response = await controller.getAccountEtherBalance(address);
-      expect(balanceServiceMock.getBalance).toBeCalledWith(address, L2_ETH_TOKEN_ADDRESS);
+      expect(balanceServiceMock.getBalance).toBeCalledWith(address, BASE_TOKEN_L2_ADDRESS);
       expect(response).toEqual({
         status: ResponseStatus.OK,
         message: ResponseMessage.OK,
@@ -588,7 +588,7 @@ describe("AccountController", () => {
 
     it("calls balanceService.getBalancesByAddresses and returns accounts ether balances", async () => {
       const response = await controller.getAccountsEtherBalances([address, "address2"]);
-      expect(balanceServiceMock.getBalancesByAddresses).toBeCalledWith([address, "address2"], L2_ETH_TOKEN_ADDRESS);
+      expect(balanceServiceMock.getBalancesByAddresses).toBeCalledWith([address, "address2"], BASE_TOKEN_L2_ADDRESS);
       expect(response).toEqual({
         status: ResponseStatus.OK,
         message: ResponseMessage.OK,

packages/api/src/api/account/account.controller.ts

@@ -1,6 +1,6 @@
 import { Controller, Get, Query, Logger, UseFilters, ParseArrayPipe, BadRequestException } from "@nestjs/common";
 import { ApiTags, ApiExcludeController } from "@nestjs/swagger";
-import { L2_ETH_TOKEN_ADDRESS } from "../../common/constants";
+import { BASE_TOKEN_L2_ADDRESS } from "../../common/constants";
 import { TokenType } from "../../token/token.entity";
 import { dateToTimestamp } from "../../common/utils";
 import { BlockService } from "../../block/block.service";
@@ -176,7 +176,7 @@ export class AccountController {
   public async getAccountEtherBalance(
     @Query("address", new ParseAddressPipe()) address: string
   ): Promise<AccountEtherBalanceResponseDto> {
-    const balance = await this.balanceService.getBalance(address, L2_ETH_TOKEN_ADDRESS);
+    const balance = await this.balanceService.getBalance(address, BASE_TOKEN_L2_ADDRESS);
     return {
       status: ResponseStatus.OK,
       message: ResponseMessage.OK,
@@ -201,7 +201,7 @@ export class AccountController {
     if (uniqueAddresses.length > 20) {
       throw new BadRequestException("Maximum 20 addresses per request");
     }
-    const balances = await this.balanceService.getBalancesByAddresses(addresses, L2_ETH_TOKEN_ADDRESS);
+    const balances = await this.balanceService.getBalancesByAddresses(addresses, BASE_TOKEN_L2_ADDRESS);
     const result = addresses.map((address) => ({
       account: address,
       balance: balances.find((balance) => balance.address.toLowerCase() === address.toLowerCase())?.balance || "0",

packages/api/src/api/mappers/internalTransactionMapper.spec.ts

@@ -1,6 +1,6 @@
 import { Transfer } from "../../transfer/transfer.entity";
 import { TransactionStatus } from "../../transaction/entities/transaction.entity";
-import { L2_ETH_TOKEN_ADDRESS } from "../../common/constants";
+import { BASE_TOKEN_L2_ADDRESS } from "../../common/constants";
 import { mapInternalTransactionListItem } from "./internalTransactionMapper";
 
 describe("internalTransactionMapper", () => {
@@ -11,7 +11,7 @@ describe("internalTransactionMapper", () => {
     from: "0xc7e0220d02d549c4846A6EC31D89C3B670Ebe35C",
     to: "0xc7e0220d02d549c4846A6EC31D89C3B670Ebe35D",
     amount: "1000000",
-    tokenAddress: L2_ETH_TOKEN_ADDRESS,
+    tokenAddress: BASE_TOKEN_L2_ADDRESS,
     transaction: {
       blockNumber: 20,
       receivedAt: new Date("2023-01-01"),

packages/api/src/api/stats/stats.controller.spec.ts

@@ -2,8 +2,9 @@ import { Test } from "@nestjs/testing";
 import { mock } from "jest-mock-extended";
 import { Logger } from "@nestjs/common";
 import { TokenService } from "../../token/token.service";
-import { Token, ETH_TOKEN } from "../../token/token.entity";
+import { Token } from "../../token/token.entity";
 import { StatsController } from "./stats.controller";
+import { baseTokenData } from "../../config";
 
 describe("StatsController", () => {
   let controller: StatsController;
@@ -31,7 +32,7 @@ describe("StatsController", () => {
   describe("ethPrice", () => {
     it("returns ok response and ETH price when ETH token is found", async () => {
       jest.spyOn(tokenServiceMock, "findOne").mockResolvedValueOnce({
-        usdPrice: ETH_TOKEN.usdPrice,
+        usdPrice: baseTokenData.usdPrice,
         offChainDataUpdatedAt: new Date("2023-03-03"),
       } as Token);
 
@@ -40,7 +41,7 @@ describe("StatsController", () => {
         status: "1",
         message: "OK",
         result: {
-          ethusd: ETH_TOKEN.usdPrice.toString(),
+          ethusd: baseTokenData.usdPrice.toString(),
           ethusd_timestamp: Math.floor(new Date("2023-03-03").getTime() / 1000).toString(),
         },
       });

packages/api/src/api/stats/stats.controller.ts

@@ -4,8 +4,8 @@ import { ResponseStatus, ResponseMessage } from "../dtos/common/responseBase.dto
 import { ApiExceptionFilter } from "../exceptionFilter";
 import { EthPriceResponseDto } from "../dtos/stats/ethPrice.dto";
 import { TokenService } from "../../token/token.service";
-import { ETH_TOKEN } from "../../token/token.entity";
 import { dateToTimestamp } from "../../common/utils";
+import { baseTokenData } from "../../config";
 
 const entityName = "stats";
 
@@ -18,7 +18,10 @@ export class StatsController {
 
   @Get("/ethprice")
   public async ethPrice(): Promise<EthPriceResponseDto> {
-    const token = await this.tokenService.findOne(ETH_TOKEN.l2Address, { usdPrice: true, offChainDataUpdatedAt: true });
+    const token = await this.tokenService.findOne(baseTokenData.l2Address, {
+      usdPrice: true,
+      offChainDataUpdatedAt: true,
+    });
     return {
       status: token ? ResponseStatus.OK : ResponseStatus.NOTOK,
       message: token ? ResponseMessage.OK : ResponseMessage.NO_DATA_FOUND,

packages/api/src/api/token/token.controller.spec.ts

@@ -2,9 +2,10 @@ import { Test } from "@nestjs/testing";
 import { mock } from "jest-mock-extended";
 import { Logger } from "@nestjs/common";
 import { TokenService } from "../../token/token.service";
-import { Token, ETH_TOKEN } from "../../token/token.entity";
+import { Token } from "../../token/token.entity";
 import { TokenController } from "./token.controller";
-
+import config from "../../config/index";
+const { baseTokenData } = config();
 describe("TokenController", () => {
   let controller: TokenController;
   let tokenServiceMock: TokenService;
@@ -32,22 +33,22 @@ describe("TokenController", () => {
 
   describe("tokenInfo", () => {
     it("returns ok response and token info when token is found", async () => {
-      jest.spyOn(tokenServiceMock, "findOne").mockResolvedValueOnce(ETH_TOKEN);
-
+      const baseToken = baseTokenData as Token;
+      jest.spyOn(tokenServiceMock, "findOne").mockResolvedValueOnce(baseToken);
       const response = await controller.tokenInfo(contractAddress);
       expect(response).toEqual({
         status: "1",
         message: "OK",
         result: [
           {
-            contractAddress: ETH_TOKEN.l2Address,
-            iconURL: ETH_TOKEN.iconURL,
-            l1Address: ETH_TOKEN.l1Address,
-            liquidity: ETH_TOKEN.liquidity.toString(),
-            symbol: ETH_TOKEN.symbol,
-            tokenDecimal: ETH_TOKEN.decimals.toString(),
-            tokenName: ETH_TOKEN.name,
-            tokenPriceUSD: ETH_TOKEN.usdPrice.toString(),
+            contractAddress: baseToken.l2Address,
+            iconURL: baseToken.iconURL,
+            l1Address: baseToken.l1Address,
+            liquidity: baseToken.liquidity.toString(),
+            symbol: baseToken.symbol,
+            tokenDecimal: baseToken.decimals.toString(),
+            tokenName: baseToken.name,
+            tokenPriceUSD: baseToken.usdPrice.toString(),
           },
         ],
       });

packages/api/src/api/token/token.controller.ts

@@ -5,7 +5,6 @@ import { ResponseStatus, ResponseMessage } from "../dtos/common/responseBase.dto
 import { ApiExceptionFilter } from "../exceptionFilter";
 import { TokenInfoResponseDto } from "../dtos/token/tokenInfo.dto";
 import { TokenService } from "../../token/token.service";
-
 const entityName = "token";
 
 @ApiExcludeController()

packages/api/src/balance/balance.entity.ts

@@ -1,9 +1,9 @@
 import { Entity, Column, PrimaryColumn, Index, ManyToOne, JoinColumn, AfterLoad } from "typeorm";
 import { BaseEntity } from "../common/entities/base.entity";
-import { Token, ETH_TOKEN } from "../token/token.entity";
+import { Token } from "../token/token.entity";
 import { normalizeAddressTransformer } from "../common/transformers/normalizeAddress.transformer";
 import { bigIntNumberTransformer } from "../common/transformers/bigIntNumber.transformer";
-
+import { baseTokenData } from "../config/index";
 @Entity({ name: "balances" })
 export class Balance extends BaseEntity {
   @PrimaryColumn({ type: "bytea", transformer: normalizeAddressTransformer })
@@ -24,9 +24,12 @@ export class Balance extends BaseEntity {
   public readonly balance: string;
 
   @AfterLoad()
-  populateEthToken() {
-    if (this.tokenAddress === ETH_TOKEN.l2Address && !this.token) {
-      this.token = ETH_TOKEN;
+  populateBaseToken() {
+    if (
+      !this.token &&
+      (this.tokenAddress === undefined || this.tokenAddress.toLowerCase() === baseTokenData.l2Address.toLowerCase())
+    ) {
+      this.token = baseTokenData as Token;
     }
   }
 }

packages/api/src/common/constants.ts

@@ -1 +1 @@
-export const L2_ETH_TOKEN_ADDRESS = "0x000000000000000000000000000000000000800a";
+export const BASE_TOKEN_L2_ADDRESS = "0x000000000000000000000000000000000000800A";

packages/api/src/config/index.spec.ts

@@ -1,5 +1,4 @@
 import config from "../config";
-
 jest.mock("./featureFlags", () => ({
   feature1Enabled: true,
   feature2Enabled: false,
@@ -20,6 +19,71 @@ describe("config", () => {
 
   it("sets default values", () => {
     expect(config()).toEqual({
+      baseTokenData: {
+        l2Address: "0x000000000000000000000000000000000000800A",
+        l1Address: "0x0000000000000000000000000000000000000001",
+        symbol: "ETH",
+        name: "Ether",
+        decimals: 18,
+        // Fallback data in case ETH token is not in the DB
+        iconURL: "https://assets.coingecko.com/coins/images/279/large/ethereum.png?1698873266",
+        liquidity: 220000000000,
+        usdPrice: 1800,
+      },
+      NODE_ENV: "test",
+      port: 3020,
+      metrics: {
+        port: 3005,
+        collectDbConnectionPoolMetricsInterval: 10000,
+      },
+      typeORM: {
+        type: "postgres",
+        url: "postgres://postgres:[email protected]:5432/block-explorer",
+        poolSize: 300,
+        extra: {
+          idleTimeoutMillis: 60000,
+          statement_timeout: 90000,
+        },
+        synchronize: true,
+        logging: false,
+        autoLoadEntities: true,
+        retryAttempts: 10,
+        retryDelay: 3000,
+        applicationName: "block-explorer-api",
+      },
+      contractVerificationApiUrl: "http://127.0.0.1:3070",
+      featureFlags: {
+        feature1Enabled: true,
+        feature2Enabled: false,
+      },
+      gracefulShutdownTimeoutMs: 0,
+    });
+  });
+
+  it("sets default values with base ERC20", () => {
+    process.env = {
+      BASE_TOKEN_SYMBOL: "MTTL",
+      BASE_TOKEN_DECIMALS: "18",
+      BASE_TOKEN_L1_ADDRESS: "0xSomeAddress",
+      BASE_TOKEN_ICON_URL: "https://matter-labs.io",
+      BASE_TOKEN_NAME: "MatterLabs",
+      BASE_TOKEN_LIQUIDITY: "999999999999",
+      BASE_TOKEN_USDPRICE: "19",
+      NODE_ENV: "test",
+    };
+
+    expect(config()).toEqual({
+      baseTokenData: {
+        l2Address: "0x000000000000000000000000000000000000800A",
+        l1Address: "0xSomeAddress",
+        symbol: "MTTL",
+        name: "MatterLabs",
+        decimals: 18,
+        // Fallback data in case ETH token is not in the DB
+        iconURL: "https://matter-labs.io",
+        liquidity: 999999999999,
+        usdPrice: 19,
+      },
       NODE_ENV: "test",
       port: 3020,
       metrics: {
@@ -28,7 +92,7 @@ describe("config", () => {
       },
       typeORM: {
         type: "postgres",
-        url: "postgres://postgres:postgres@localhost:5432/block-explorer",
+        url: "postgres://postgres:postgres@127.0.0.1:5432/block-explorer",
         poolSize: 300,
         extra: {
           idleTimeoutMillis: 60000,