@mtnts/contract-client 0.0.6

package/.prettierignore

@@ -0,0 +1,6 @@
+node_modules
+dist
+coverage
+pnpm-lock.yaml
+yarn.lock
+package-lock.json

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@mtnts/contract-client",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "lint-staged": {
+    "*.{ts,js,json,md}": "prettier --write"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "format": "prettier . --write",
+    "check-format": "prettier . --check",
+    "release": "pnpm build && npm version patch --no-git-tag-version && npm publish --access public"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "globby": "^16.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.7",
+    "prettier": "^3.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "version": "0.0.6"
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/prettier.config.cjs

@@ -0,0 +1,8 @@
+module.exports = {
+    semi: true,
+    singleQuote: false,
+    tabWidth: 2,
+    trailingComma: "all",
+    printWidth: 100,
+    arrowParens: "always",
+  };

package/src/cli/index.ts

@@ -0,0 +1,81 @@
+import { globby } from "globby";
+import fs from "node:fs";
+import path from "node:path";
+import { abiToTs, getStructString } from "./io-to-ts";
+import {
+  ask,
+  contractsTemplate,
+  createEventsName,
+  createMethodsName,
+  normalizePath,
+  writePrettyFile,
+} from "./utils";
+import { AbiItem } from "src/types";
+
+type Abis = [string, AbiItem[]][];
+
+function createGlobalDeclaration(content: string[] | string) {
+  const finalContent = Array.isArray(content) ? content.join("\n") : content;
+  return ` export {}
+               declare global {
+               ${finalContent}
+               }`;
+}
+
+function defineMethods(abiName: string, items: AbiItem[]) {
+  const content = items
+    .map((item) => {
+      const inputs = abiToTs(item.inputs, "in");
+      const outputs = abiToTs(item.outputs!, "out");
+      return `\n${item.name}: [${inputs},${outputs}]`;
+    })
+    .join("");
+  return createGlobalDeclaration(`type ${createMethodsName(abiName)} = {${content}}`);
+}
+
+function defineEvents(abiName: string, items: AbiItem[]) {
+  const content = items
+    .map((item) => {
+      return `\n${item.name}: ${abiToTs(item.inputs!, "out")}`;
+    })
+    .join("");
+  return createGlobalDeclaration(`type ${createEventsName(abiName)} = {${content}}`);
+}
+
+function defineAllContracts(abis: Abis) {
+  const content = abis.map(([name]) => {
+    return `\n${name}: ${createMethodsName(name)}`;
+  });
+  const allMehodsString = `type ContractMethods = RegistryHandlers<{${content}}, ContractOptions>`;
+  return createGlobalDeclaration(contractsTemplate + allMehodsString);
+}
+
+export async function generateBlockchainTypes() {
+  const rootPath = process.cwd();
+  const _input = await ask("type relative path: ");
+  const input = _input ? _input + "/" : "";
+  const outDir = path.resolve(rootPath, `src/${input}@bc-types`);
+
+  const filePaths = await globby(`src/${input}abis/*.abi.json`, {
+    cwd: rootPath,
+    absolute: true,
+  });
+
+  const abis = filePaths.map((filePath: string) => [
+    normalizePath(filePath),
+    JSON.parse(fs.readFileSync(filePath, "utf-8")),
+  ]) as Abis;
+
+  abis.forEach(async ([name, abiArray]) => {
+    const dir = path.resolve(outDir, name);
+    const methods = abiArray.filter((i) => i.type === "function");
+    const events = abiArray.filter((i) => i.type === "event");
+
+    writePrettyFile(`${name}.methods.d.ts`, defineMethods(name, methods), dir);
+    writePrettyFile(`${name}.events.d.ts`, defineEvents(name, events), dir);
+  });
+
+  const structsString = createGlobalDeclaration(getStructString());
+  writePrettyFile(`structs.d.ts`, structsString, outDir);
+  writePrettyFile(`contracts.d.ts`, defineAllContracts(abis), outDir);
+}

package/src/cli/io-to-ts.ts

@@ -0,0 +1,70 @@
+const structs = new Map<string, string>();
+
+function solidityPrimitiveToTs(type: string): string {
+  if (["string", "address"].includes(type) || type.startsWith("byte")) return "string";
+  if (type.startsWith("uint")) return "number";
+  if (type === "bool") return "boolean";
+  throw new Error(`[abiTypeToTsType] Not handle type: ${type}`);
+}
+
+function normalizeStructName(internalType?: string) {
+  if (!internalType) {
+    return "UnknownStruct";
+  }
+
+  const rawName = internalType.split(" ")[1] ?? "UnknownStruct";
+
+  return `BC${rawName.replace("[]", "").replaceAll(".", "")}`;
+}
+
+function buildTsObjectType(ios: any[], ioType: string): string {
+  if (!ios?.length) {
+    return ioType === "in" ? "null" : "void";
+  }
+
+  if (ios.length === 1 && ios[0].name === "" && ioType === "out") {
+    return abiTypeToTsType(ios[0], ioType);
+  }
+
+  const fields = ios
+    .map((item) => `${item.name || '""'}: ${abiTypeToTsType(item, ioType)}`)
+    .join("; ");
+
+  return `{ ${fields} }`;
+}
+
+function getOrCreateStructType(item: any, ioType: string): string {
+  const structName = normalizeStructName(item.internalType);
+
+  if (!structs.has(structName)) {
+    const body = buildTsObjectType(item.components ?? [], ioType);
+
+    structs.set(structName, `type ${structName} = ${body}`);
+  }
+
+  return structName;
+}
+
+function abiTypeToTsType(item: any, ioType: string): string {
+  const isArray = item.type.endsWith("[]");
+
+  if (item.type.includes("tuple")) {
+    const structName = getOrCreateStructType(item, ioType);
+
+    return isArray ? `${structName}[]` : structName;
+  }
+
+  const baseType = isArray ? item.type.slice(0, -2) : item.type;
+
+  const tsType = solidityPrimitiveToTs(baseType);
+
+  return isArray ? `${tsType}[]` : tsType;
+}
+
+export function abiToTs(ios: any[], ioType: string) {
+  return buildTsObjectType(ios, ioType);
+}
+
+export function getStructString() {
+  return [...structs.values()].join("\n");
+}

package/src/cli/utils.ts

@@ -0,0 +1,69 @@
+import path from "node:path";
+import fs from "node:fs";
+import prettier from "prettier";
+import readline from "readline";
+
+export function ask(label: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(label, (answer) => {
+      rl.close();
+
+      const rs = answer.trim();
+
+      resolve(rs);
+    });
+  });
+}
+
+export function capitalize(input: string) {
+  return input.charAt(0).toUpperCase() + input.slice(1);
+}
+
+export function createMethodsName(name: string) {
+  return `${capitalize(name)}Mehods`;
+}
+
+export function createEventsName(name: string) {
+  return `${capitalize(name)}Events`;
+}
+
+export function normalizePath(input: string) {
+  return path.basename(input, ".abi.json").split(/[-.]/g).join("");
+}
+
+export async function writePrettyFile(fileName: string, content: string, outDir: string) {
+  fs.mkdirSync(outDir, {
+    recursive: true,
+  });
+  const outFile = path.join(outDir, fileName);
+  const config = await prettier.resolveConfig(outFile);
+  const formatted = await prettier.format(content, {
+    ...config,
+    filepath: outFile,
+  });
+  fs.writeFileSync(outFile, formatted, "utf-8");
+}
+
+export const contractsTemplate = ` type HandlerDefinition<Input = unknown, Output = unknown> = [Input, Output];
+
+ type RegistrySchema = Record<string, Record<string, HandlerDefinition<unknown, unknown>>>;
+
+ type RegistryHandlers<TSchema extends RegistrySchema, TOptions = unknown> = {
+  [TGroup in keyof TSchema]: {
+    [TKey in keyof TSchema[TGroup]]: (
+      input: TSchema[TGroup][TKey][0],
+      options?: TOptions,
+    ) => Promise<TSchema[TGroup][TKey][1]>;
+  };
+};
+type ContractOptions = {
+    from?: string
+    to?: string
+    gas?: string | number
+  }
+`;

package/src/index.ts

@@ -0,0 +1 @@
+console.log("hello lib");

package/src/types.ts

@@ -0,0 +1,20 @@
+export interface AbiIO {
+  indexed?: boolean;
+  internalType?: string;
+  name?: string;
+  type: string;
+  components?: AbiIO[];
+  [key: string]: any;
+}
+
+export interface AbiItem {
+  inputs: AbiIO[];
+  type: string;
+  name?: string;
+  outputs?: AbiIO[];
+  stateMutability?: string;
+  anonymous?: boolean;
+  indexed?: boolean;
+  internalType?: string;
+  [key: string]: any;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "declaration": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "baseUrl": "."
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig([
+  {
+    entry: ["src/index.ts"],
+    format: ["esm", "cjs"],
+    dts: true,
+    sourcemap: true,
+    clean: true,
+    minify: false,
+    target: "es2020",
+    outDir: "dist",
+  },
+  {
+    entry: {
+      cli: "src/cli/index.ts",
+    },
+    format: ["cjs"],
+    platform: "node",
+    external: ["fast-glob", "prettier"],
+    banner: {
+      js: "#!/usr/bin/env node",
+    },
+    tsconfig: "./tsconfig.json", // Buộc tsup đọc tsconfig
+  },
+]);