@evergonlabs/tmi-protocol-api 0.1.3 → 0.1.4

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

@@ -1,78 +0,0 @@
-import { z } from "zod";
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare enum Erc20Role {
-    WHITELISTED_SPENDER_ROLE = "WHITELISTED_SPENDER_ROLE"
-}
-export declare const GrantRoleSchema: z.ZodObject<{
-    role: z.ZodNativeEnum<typeof Erc20Role>;
-    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    address: `0x${string}`;
-    role: Erc20Role;
-    tokenAddress: `0x${string}`;
-}, {
-    address: `0x${string}`;
-    role: Erc20Role;
-    tokenAddress: `0x${string}`;
-}>;
-export declare function createGrantRole<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: {
-            address: `0x${string}`;
-            role: Erc20Role;
-            tokenAddress: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            address: `0x${string}`;
-            role: Erc20Role;
-            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: {
-            address: `0x${string}`;
-            role: Erc20Role;
-            tokenAddress: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            address: `0x${string}`;
-            role: Erc20Role;
-            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=grantRole.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/grantRole.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;AAKvC,oBAAY,SAAS;IACnB,wBAAwB,6BAA6B;CACtD;AAQD,eAAO,MAAM,eAAe;;;;;;;;;;;;EAO1B,CAAC;AAkBH,wBAAgB,eAAe,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAejE"}

package/dist/src/issuance/grantRole.js

@@ -1,50 +0,0 @@
-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 { keccak256, toHex } from "viem";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
-export var Erc20Role;
-(function (Erc20Role) {
-    Erc20Role["WHITELISTED_SPENDER_ROLE"] = "WHITELISTED_SPENDER_ROLE";
-})(Erc20Role || (Erc20Role = {}));
-// Convert role string to keccak256 hash
-function convertRoleToHash(role) {
-    return keccak256(toHex(role));
-}
-// Define the schema for the grant role request
-export const GrantRoleSchema = z.object({
-    role: z.nativeEnum(Erc20Role).openapi({
-        description: "The role to grant to the address",
-        example: Erc20Role.WHITELISTED_SPENDER_ROLE,
-    }),
-    address: AddressSchema.openapi("The address to grant the role to"),
-    tokenAddress: AddressSchema.openapi("The address of the ERC20 token contract"),
-});
-const grantRoleRoute = describeRoute({
-    summary: "Grant Role to Address",
-    description: "Returns transaction data for granting a role to an address",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for granting a role",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function createGrantRole(factory) {
-    return factory.createHandlers(grantRoleRoute, validator("json", GrantRoleSchema), async (c) => {
-        const { role, address, tokenAddress } = c.req.valid("json");
-        const roleHash = convertRoleToHash(role);
-        return c.json(toTransaction({
-            address: tokenAddress,
-            abi: erc20GatedAbi,
-            functionName: "grantRole",
-            args: [roleHash, address],
-        }));
-    });
-}

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

@@ -1,165 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,23 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-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

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

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

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

package/dist/src/serve.js

@@ -1,33 +0,0 @@
-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);
-});