@evergonlabs/tmi-protocol-api 0.2.1 → 0.4.0

package/dist/src/issuance/index.d.ts

@@ -0,0 +1,165 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const issuanceApis: {
+    name: string;
+    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/erc20": {
+            $get: {
+                input: {};
+                output: {
+                    abi: any[];
+                    bytecode: `0x${string}`;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/mint": {
+            $post: {
+                input: {
+                    json: {
+                        amount: bigint;
+                        tokenAddress: `0x${string}`;
+                        mintTo: `0x${string}`;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/burn": {
+            $post: {
+                input: {
+                    json: {
+                        amount: bigint;
+                        burnFrom: `0x${string}`;
+                        tokenAddress: `0x${string}`;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/approve": {
+            $post: {
+                input: {
+                    json: {
+                        amount: bigint;
+                        spender: `0x${string}`;
+                        tokenAddress: `0x${string}`;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/transfer": {
+            $post: {
+                input: {
+                    json: {
+                        to: `0x${string}`;
+                        amount: bigint;
+                        tokenAddress: `0x${string}`;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/proxy": {
+            $post: {
+                input: {
+                    json: {
+                        cap: bigint;
+                        erc20Address: `0x${string}`;
+                        defaultAdmin: `0x${string}`;
+                        minter: `0x${string}`;
+                        tokenName: string;
+                        tokenSymbol: string;
+                    };
+                };
+                output: {
+                    abi: any[];
+                    args: any[];
+                    bytecode: `0x${string}`;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/grantRole": {
+            $post: {
+                input: {
+                    json: {
+                        address: `0x${string}`;
+                        role: import("./grantRole.js").Erc20Role;
+                        tokenAddress: `0x${string}`;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    }, "/issuance">, "/">;
+    config: {
+        title: string;
+        description: string;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/issuance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,eAAO,MAAM,YAAY;;gBAEX,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB/C,CAAC"}

package/dist/src/issuance/index.js

@@ -0,0 +1,23 @@
+import { createApiConfig } from "../common/app.js";
+import { approveErc20Token } from "./approve.js";
+import { burnErc20Token } from "./burn.js";
+import { createErc1967Proxy, createErc20Token } from "./deploy.js";
+import { mintErc20Token } from "./mint.js";
+import { transferErc20Token } from "./transfer.js";
+import { createGrantRole } from "./grantRole.js";
+export const issuanceApis = {
+    name: "Issuance APIs",
+    createApp: (factory) => factory.createApp().route("/issuance", factory
+        .createApp()
+        .get("/erc20", ...createErc20Token(factory))
+        .post("/erc20/mint", ...mintErc20Token(factory))
+        .post("/erc20/burn", ...burnErc20Token(factory))
+        .post("/erc20/approve", ...approveErc20Token(factory))
+        .post("/erc20/transfer", ...transferErc20Token(factory))
+        .post("/erc20/proxy", ...createErc1967Proxy(factory))
+        .post("/erc20/grantRole", ...createGrantRole(factory))),
+    config: createApiConfig({
+        title: "Issuance API",
+        description: "APIs for issuing tokens",
+    }),
+};

package/dist/src/issuance/mint.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const MintErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amount: z.ZodBigInt;
+    mintTo: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    amount: bigint;
+    tokenAddress: `0x${string}`;
+    mintTo: `0x${string}`;
+}, {
+    amount: bigint;
+    tokenAddress: `0x${string}`;
+    mintTo: `0x${string}`;
+}>;
+export declare function mintErc20Token<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+            mintTo: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+            mintTo: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+            mintTo: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+            mintTo: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=mint.d.ts.map

package/dist/src/issuance/mint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/mint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAkBH,wBAAgB,cAAc,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAahE"}

package/dist/src/issuance/mint.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
+import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+export const MintErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    amount: z.coerce.bigint().nonnegative(),
+    mintTo: AddressSchema,
+});
+const mintRoute = describeRoute({
+    summary: "Mint Gated ERC20",
+    description: "Returns transaction data for minting a gated ERC20",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for minting a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function mintErc20Token(factory) {
+    return factory.createHandlers(mintRoute, validator("json", MintErc20RequestSchema), async (c) => {
+        const { tokenAddress, amount, mintTo } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: erc20GatedAbi,
+            functionName: "mint",
+            args: [mintTo, BigInt(amount).toString()],
+        }));
+    });
+}

package/dist/src/issuance/transfer.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const TransferErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    to: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amount: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    to: `0x${string}`;
+    amount: bigint;
+    tokenAddress: `0x${string}`;
+}, {
+    to: `0x${string}`;
+    amount: bigint;
+    tokenAddress: `0x${string}`;
+}>;
+export declare function transferErc20Token<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            to: `0x${string}`;
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            to: `0x${string}`;
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            to: `0x${string}`;
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            to: `0x${string}`;
+            amount: bigint;
+            tokenAddress: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=transfer.d.ts.map

package/dist/src/issuance/transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/transfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAIrC,CAAC;AAkBH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAapE"}

package/dist/src/issuance/transfer.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
+import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+export const TransferErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    to: AddressSchema,
+    amount: z.coerce.bigint().nonnegative(),
+});
+const transferRoute = describeRoute({
+    summary: "Transfer Gated ERC20",
+    description: "Returns transaction data for transferring a gated ERC20 token to another address",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for transferring a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function transferErc20Token(factory) {
+    return factory.createHandlers(transferRoute, validator("json", TransferErc20RequestSchema), async (c) => {
+        const { tokenAddress, to, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: erc20GatedAbi,
+            functionName: "transfer",
+            args: [to, BigInt(amount).toString()],
+        }));
+    });
+}

package/dist/src/serve.d.ts

@@ -0,0 +1,2 @@
+import "dotenv/config";
+//# sourceMappingURL=serve.d.ts.map

package/dist/src/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/serve.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC"}

package/dist/src/serve.js

@@ -0,0 +1,33 @@
+import "dotenv/config";
+import kleur from "kleur";
+import { serve } from "@hono/node-server";
+import { apiReference } from "@scalar/hono-api-reference";
+import { swaggerUI } from "@hono/swagger-ui";
+import { logger } from "hono/logger";
+import { showRoutes } from "hono/dev";
+import { createFactory } from "hono/factory";
+import { createApiConfig } from "./common/app.js";
+import { getApp } from "./app.js";
+import { config } from "./common/config.js";
+import { openAPISpecs } from "hono-openapi";
+import { getOpenApiSpec } from "./common/openapi.js";
+const openapiUrl = "/openapi";
+const baseApp = getApp(createFactory());
+const app = baseApp
+    .get("/openapi", openAPISpecs(baseApp, getOpenApiSpec(createApiConfig({
+    title: "Protocol API",
+    description: "Fractions and Staking API for Decentralized finance",
+}), config.baseUrl)))
+    .get("/scalar", apiReference({ theme: "kepler", spec: { url: openapiUrl } }))
+    .get("/swagger", swaggerUI({ url: openapiUrl }))
+    .get("/health", (c) => c.json({ status: "ok" }))
+    .use(logger());
+serve({
+    fetch: app.fetch,
+    port: config.port,
+}, (x) => {
+    console.log(kleur.green(`Server started on port: http://localhost:${x.port}`));
+    console.log(kleur.cyan(`Discover Swagger on http://localhost:${x.port}/swagger`));
+    console.log(kleur.gray(`Server config: ${JSON.stringify(config, null, 2)})`));
+    showRoutes(app);
+});