[EPIC] V1

.eslintrc.cjs

@@ -0,0 +1,67 @@
+module.exports = {
+  ignorePatterns: ["lib/**", "**/*.js"],
+  parser: "@typescript-eslint/parser",
+  plugins: ["@typescript-eslint", "tsdoc"],
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended-type-checked",
+    "prettier",
+  ],
+  parserOptions: {
+    project: ["./tsconfig.json"],
+  },
+  env: {
+    node: true,
+  },
+  rules: {
+    "@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
+    "@typescript-eslint/no-unnecessary-condition": "error",
+    "@typescript-eslint/no-unnecessary-qualifier": "error",
+    "@typescript-eslint/no-unnecessary-template-expression": "error",
+    "@typescript-eslint/no-unnecessary-type-arguments": "error",
+    "@typescript-eslint/no-unnecessary-type-assertion": "error",
+    "@typescript-eslint/no-unnecessary-type-constraint": "error",
+    "@typescript-eslint/explicit-member-accessibility": [
+      "error",
+      {
+        accessibility: "explicit",
+        overrides: {
+          accessors: "explicit",
+          constructors: "explicit",
+          methods: "explicit",
+          properties: "explicit",
+          parameterProperties: "explicit",
+        },
+      },
+    ],
+    "no-shadow": "error",
+    "@typescript-eslint/consistent-type-imports": "error",
+    "@typescript-eslint/naming-convention": [
+      "error",
+      {
+        selector: "variable",
+        types: ["boolean"],
+        format: ["PascalCase", "UPPER_CASE"],
+        prefix: [
+          "is",
+          "should",
+          "has",
+          "can",
+          "did",
+          "will",
+          "does",
+          "IS",
+          "SHOULD",
+          "HAS",
+        ],
+      },
+      {
+        selector: "typeLike",
+        format: ["PascalCase"],
+      },
+    ],
+    "@typescript-eslint/array-type": ["error", { default: "generic" }],
+    "new-cap": "warn",
+    "tsdoc/syntax": "error",
+  },
+};

.gitignore

@@ -2,3 +2,8 @@ node_modules
 dist
 lib
 types
+.env
+.eslintcache
+
+package-lock.json
+yarn.lock

.husky/pre-commit

@@ -1,5 +1,6 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-npx lint-staged
-npm run test
+bun run scripts/db/generate-db-json.ts
+npx lint-staged --concurrent false
+npx concurrently -g -n "eslint,test:unit,build" -c "#341BAB,#A6CC66,#3077C6" "bun run lint" "bun test unit" "bun run build"

Dockerfile

@@ -0,0 +1,16 @@
+# Use the offical Bun image
+FROM oven/bun as base
+
+# Set the Docker working directory as /usr/src/app
+# Copy everything from here into Docker's /usr/src/app
+WORKDIR /usr/src/app
+COPY . /usr/src/app
+
+FROM base AS install
+RUN cd /usr/src/app && bun install --frozen-lockfile
+
+# The port that Elysia will listen on
+EXPOSE 3000
+
+# Run the Elysia webserver
+CMD bun run api/index.ts

api/index.ts

@@ -0,0 +1,116 @@
+import { swagger } from "@elysiajs/swagger";
+import { Elysia, t } from "elysia";
+import type {
+  AccountSearchOptions,
+  TokenSearchOptions,
+} from "../scripts/db/types";
+import { selectAllLabels } from "./services/select-all-labels";
+import {
+  selectMatchingLabels,
+  selectMatchingLabelsFromQueryAccounts,
+  selectMatchingLabelsFromQueryTokens,
+} from "./services/select-matching-labels";
+
+const PORT = process.env.PORT || 3000;
+export const app = new Elysia();
+
+app.use(
+  swagger({
+    documentation: {
+      info: {
+        title: "Eth Labels API",
+        version: "0.0.0",
+      },
+    },
+  }),
+);
+
+app.get("/labels", () => {
+  return selectAllLabels();
+});
+app.get(
+  "/labels/:address",
+  async ({ params }) => {
+    const { address } = params;
+    return selectMatchingLabels(address);
+  },
+  { params: t.Object({ address: t.String() }) },
+);
+
+app.get(
+  "/accounts",
+  async ({ query }) => {
+    const {
+      chainId,
+      address,
+      label,
+      nameTag,
+      offset,
+      limit,
+    }: AccountSearchOptions = query;
+    const conditions: AccountSearchOptions = {
+      chainId,
+      address,
+      label,
+      nameTag,
+      offset,
+      limit,
+    };
+    return selectMatchingLabelsFromQueryAccounts(conditions);
+  },
+  {
+    query: t.Object({
+      chainId: t.Optional(t.String()),
+      address: t.Optional(t.String()),
+      label: t.Optional(t.String()),
+      nameTag: t.Optional(t.String()),
+      offset: t.Optional(t.String()),
+      limit: t.Optional(t.String()),
+    }),
+  },
+);
+
+app.get(
+  "/tokens",
+  ({ query }) => {
+    const {
+      chainId,
+      address,
+      label,
+      name,
+      website,
+      symbol,
+      offset,
+      limit,
+    }: TokenSearchOptions = query;
+    const conditions: TokenSearchOptions = {
+      chainId,
+      address,
+      label,
+      name,
+      website,
+      symbol,
+      offset,
+      limit,
+    };
+    return selectMatchingLabelsFromQueryTokens(conditions);
+  },
+  {
+    query: t.Object({
+      chainId: t.Optional(t.String()),
+      address: t.Optional(t.String()),
+      label: t.Optional(t.String()),
+      name: t.Optional(t.String()),
+      website: t.Optional(t.String()),
+      symbol: t.Optional(t.String()),
+      offset: t.Optional(t.String()),
+      limit: t.Optional(t.String()),
+    }),
+  },
+);
+
+app.get("/health", () => "OK");
+
+app.listen(PORT, () => {
+  console.log(`Listening on port ${PORT}. Open /swagger to see the API docs.`);
+});

api/index.unit.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "bun:test";
+import { z } from "zod";
+import { app } from ".";
+
+const fetchLocally = async (path: string) => {
+  return app
+    .handle(new Request(`http://localhost:3000${path}`))
+    .then((res) => res.json());
+};
+describe("Elysia", () => {
+  it("/labels", async () => {
+    const labels = z.array(z.string()).parse(await fetchLocally("/labels"));
+
+    expect(labels.length).toBeGreaterThan(702);
+    expect(labels).toContain("coinbase");
+  });
+
+  it("/accounts", async () => {
+    const coinbaseAccounts = z
+      .array(z.object({ address: z.string(), nameTag: z.string() }))
+      .parse(await fetchLocally("/accounts?nameTag=cOinBase%208&chainId=1"));
+
+    expect(coinbaseAccounts.length).toBe(1);
+    expect(coinbaseAccounts).toContainEqual({
+      address: "0x02466e547bfdab679fc49e96bbfc62b9747d997c",
+      nameTag: "Coinbase 8",
+    });
+
+    const accounts = z
+      .array(z.object({ address: z.string(), nameTag: z.string() }))
+      .parse(
+        await fetchLocally(
+          "/accounts?address=0x000037bb05b2Cef17c6469f4BCdb198826CE0000",
+        ),
+      );
+
+    expect(accounts.length).toBe(5);
+    expect(accounts).toContainEqual({
+      address: "0x000037bb05b2cef17c6469f4bcdb198826ce0000",
+      nameTag: "Fake_Phishing8",
+    });
+  });
+
+  it("/tokens", async () => {
+    const tokens = z
+      .array(
+        z.object({
+          address: z.string(),
+          label: z.string(),
+          name: z.string(),
+          symbol: z.string(),
+        }),
+      )
+      .parse(
+        await fetchLocally("/tokens?name=UbEsWaP&symbol=ubE"), // test case sensitivity
+      );
+
+    expect(tokens.length).toBe(3);
+    expect(tokens).toContainEqual({
+      address: "0x00be915b9dcf56a3cbe739d9b9c202ca692409ec",
+      label: "defi",
+      name: "Ubeswap",
+      symbol: "UBE",
+    });
+  });
+});

api/services/select-all-labels.ts

@@ -0,0 +1,12 @@
+import { AccountsRepository } from "../../scripts/db/repositories/AccountsRepository";
+import { TokensRepository } from "../../scripts/db/repositories/TokensRepository";
+
+export const selectAllLabels = async (): Promise<ReadonlyArray<string>> => {
+  const [allTokenLabels, allAccountLabels] = await Promise.all([
+    TokensRepository.selectAllLabels(),
+    AccountsRepository.selectAllLabels(),
+  ]);
+  const sortedLabels = allTokenLabels.concat(allAccountLabels).sort();
+  // deduplicate repeats
+  return Array.from(new Set(sortedLabels));
+};

api/services/select-matching-labels.ts

@@ -0,0 +1,57 @@
+import type { Address } from "viem";
+import { createPublicClient, http, isAddress } from "viem";
+import { mainnet } from "viem/chains";
+import { normalize } from "viem/ens";
+import { AccountsRepository } from "../../scripts/db/repositories/AccountsRepository";
+import { TokensRepository } from "../../scripts/db/repositories/TokensRepository";
+import type {
+  AccountSearchOptions,
+  TokenSearchOptions,
+} from "../../scripts/db/types";
+
+const publicClient = createPublicClient({
+  chain: mainnet,
+  transport: http(),
+});
+async function findMatchingRows(address: Address) {
+  address = address.toLowerCase() as Address;
+  const matchingRows = await Promise.all([
+    TokensRepository.selectTokensByAddress(address),
+    AccountsRepository.selectAccountsByAddress(address),
+  ]);
+  return matchingRows.flat();
+}
+
+export const selectMatchingLabels = async (address: string) => {
+  if (address.includes(".")) {
+    try {
+      const ensAddress = await publicClient.getEnsAddress({
+        name: normalize(address),
+      });
+      if (ensAddress === null) {
+        return { error: "ENS address not found" };
+      }
+      return findMatchingRows(ensAddress);
+    } catch (error) {
+      console.error("Error resolving ENS address:", error);
+      return { error: "Failed to resolve ENS address" };
+    }
+  } else {
+    if (!isAddress(address)) {
+      return { error: "Invalid address format" };
+    }
+    return findMatchingRows(address);
+  }
+};
+
+export const selectMatchingLabelsFromQueryAccounts = (
+  accounts: AccountSearchOptions,
+) => {
+  return AccountsRepository.selectAccountsByObj(accounts);
+};
+
+export const selectMatchingLabelsFromQueryTokens = (
+  tokens: TokenSearchOptions,
+) => {
+  return TokensRepository.selectTokensByObj(tokens);
+};