fix: return eth token even if it's not in DB

docker-compose-cli.yaml

@@ -5,8 +5,6 @@ services:
     build:
       context: .
       dockerfile: ./packages/app/Dockerfile
-    environment:
-      - VITE_APP_ENVIRONMENT=local
     ports:
       - '3010:3010'
     depends_on:
@@ -27,10 +25,6 @@ services:
       - DATABASE_NAME=block-explorer
       - BLOCKCHAIN_RPC_URL=http://host.docker.internal:3050
       - BATCHES_PROCESSING_POLLING_INTERVAL=1000
-    ports:
-      - '3001:3001'
-      - '9229:9229'
-      - '9230:9230'
     restart: unless-stopped
 
   api:
@@ -45,9 +39,6 @@ services:
       - DATABASE_URL=postgres://postgres:postgres@postgres:5432/block-explorer
     ports:
       - '3020:3020'
-      - '3005:3005'
-      - '9231:9229'
-      - '9232:9230'
     depends_on:
       - worker
     restart: unless-stopped
@@ -58,8 +49,6 @@ services:
       driver: none 
     volumes:
       - postgres:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
     healthcheck:
       test: [ "CMD-SHELL", "pg_isready -U postgres" ]
       interval: 5s

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

@@ -1,6 +1,6 @@
-import { Entity, Column, PrimaryColumn, Index, ManyToOne, JoinColumn } from "typeorm";
+import { Entity, Column, PrimaryColumn, Index, ManyToOne, JoinColumn, AfterLoad } from "typeorm";
 import { BaseEntity } from "../common/entities/base.entity";
-import { Token } from "../token/token.entity";
+import { Token, ETH_TOKEN } from "../token/token.entity";
 import { normalizeAddressTransformer } from "../common/transformers/normalizeAddress.transformer";
 import { bigIntNumberTransformer } from "../common/transformers/bigIntNumber.transformer";
 
@@ -9,9 +9,9 @@ export class Balance extends BaseEntity {
   @PrimaryColumn({ type: "bytea", transformer: normalizeAddressTransformer })
   public readonly address: string;
 
-  @ManyToOne(() => Token)
+  @ManyToOne(() => Token, { createForeignKeyConstraints: false })
   @JoinColumn({ name: "tokenAddress" })
-  public readonly token?: Token;
+  public token?: Token;
 
   @PrimaryColumn({ type: "bytea", transformer: normalizeAddressTransformer })
   public readonly tokenAddress: string;
@@ -22,4 +22,11 @@ export class Balance extends BaseEntity {
 
   @Column({ type: "varchar", length: 128 })
   public readonly balance: string;
+
+  @AfterLoad()
+  populateEthToken() {
+    if (this.tokenAddress === ETH_TOKEN.l2Address && !this.token) {
+      this.token = ETH_TOKEN;
+    }
+  }
 }

packages/api/src/token/token.entity.ts

@@ -8,6 +8,14 @@ export enum TokenType {
   ERC721 = "ERC721",
 }
 
+export const ETH_TOKEN: Token = {
+  l2Address: "0x000000000000000000000000000000000000800A",
+  l1Address: null,
+  symbol: "ETH",
+  name: "Ether",
+  decimals: 18,
+} as Token;
+
 @Entity({ name: "tokens" })
 @Index(["blockNumber", "logIndex"])
 export class Token extends BaseEntity {

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

@@ -54,6 +54,28 @@ describe("TokenService", () => {
       const result = await service.findOne(tokenAddress);
       expect(result).toBe(token);
     });
+
+    describe("when requested token does not exist", () => {
+      beforeEach(() => {
+        (repositoryMock.findOneBy as jest.Mock).mockResolvedValue(null);
+      });
+
+      it("returns ETH token for ETH address", async () => {
+        const result = await service.findOne("0x000000000000000000000000000000000000800a");
+        expect(result).toEqual({
+          decimals: 18,
+          l1Address: null,
+          l2Address: "0x000000000000000000000000000000000000800A",
+          name: "Ether",
+          symbol: "ETH",
+        });
+      });
+
+      it("returns null for non ETH address", async () => {
+        const result = await service.findOne("0x000000000000000000000000000000000000800b");
+        expect(result).toBeNull();
+      });
+    });
   });
 
   describe("exists", () => {
@@ -82,10 +104,20 @@ describe("TokenService", () => {
       expect(result).toBe(true);
     });
 
-    it("returns false if there is no token with the specified address", async () => {
-      (repositoryMock.findOne as jest.Mock).mockResolvedValue(null);
-      const result = await service.exists(tokenAddress);
-      expect(result).toBe(false);
+    describe("when requested token does not exist", () => {
+      beforeEach(() => {
+        (repositoryMock.findOne as jest.Mock).mockResolvedValue(null);
+      });
+
+      it("returns true for ETH address", async () => {
+        const result = await service.exists("0x000000000000000000000000000000000000800a");
+        expect(result).toBe(true);
+      });
+
+      it("returns false for non ETH address", async () => {
+        const result = await service.exists(tokenAddress);
+        expect(result).toBe(false);
+      });
     });
   });
 

packages/api/src/token/token.service.ts

@@ -3,7 +3,7 @@ import { InjectRepository } from "@nestjs/typeorm";
 import { Repository } from "typeorm";
 import { Pagination, IPaginationOptions } from "nestjs-typeorm-paginate";
 import { paginate } from "../common/utils";
-import { Token } from "./token.entity";
+import { Token, ETH_TOKEN } from "./token.entity";
 
 @Injectable()
 export class TokenService {
@@ -13,11 +13,20 @@ export class TokenService {
   ) {}
 
   public async findOne(address: string): Promise<Token> {
-    return await this.tokenRepository.findOneBy({ l2Address: address });
+    const token = await this.tokenRepository.findOneBy({ l2Address: address });
+    if (!token && address === ETH_TOKEN.l2Address.toLowerCase()) {
+      return ETH_TOKEN;
+    }
+    return token;
   }
 
   public async exists(address: string): Promise<boolean> {
-    return (await this.tokenRepository.findOne({ where: { l2Address: address }, select: { l2Address: true } })) != null;
+    const tokenExists =
+      (await this.tokenRepository.findOne({ where: { l2Address: address }, select: { l2Address: true } })) != null;
+    if (!tokenExists && address === ETH_TOKEN.l2Address.toLowerCase()) {
+      return true;
+    }
+    return tokenExists;
   }
 
   public async findAll(paginationOptions: IPaginationOptions): Promise<Pagination<Token>> {

packages/api/src/transfer/transfer.entity.ts

@@ -1,6 +1,6 @@
-import { Entity, Column, Index, ManyToOne, JoinColumn, PrimaryColumn } from "typeorm";
+import { Entity, Column, Index, ManyToOne, JoinColumn, PrimaryColumn, AfterLoad } from "typeorm";
 import { BaseEntity } from "../common/entities/base.entity";
-import { Token, TokenType } from "../token/token.entity";
+import { Token, TokenType, ETH_TOKEN } from "../token/token.entity";
 import { normalizeAddressTransformer } from "../common/transformers/normalizeAddress.transformer";
 import { bigIntNumberTransformer } from "../common/transformers/bigIntNumber.transformer";
 import { hexTransformer } from "../common/transformers/hex.transformer";
@@ -53,9 +53,9 @@ export class Transfer extends BaseEntity {
   @Column({ type: "varchar", length: 128, nullable: true })
   public readonly amount?: string;
 
-  @ManyToOne(() => Token)
+  @ManyToOne(() => Token, { createForeignKeyConstraints: false })
   @JoinColumn({ name: "tokenAddress" })
-  public readonly token?: Token;
+  public token?: Token;
 
   @Index()
   @Column({ type: "bytea", transformer: normalizeAddressTransformer })
@@ -84,4 +84,11 @@ export class Transfer extends BaseEntity {
     const { number, ...restFields } = this;
     return restFields;
   }
+
+  @AfterLoad()
+  populateEthToken() {
+    if (!this.token && this.tokenAddress === ETH_TOKEN.l2Address) {
+      this.token = ETH_TOKEN;
+    }
+  }
 }