@evergonlabs/tmi-protocol-api 0.9.0 → 0.10.0-rc.0

package/dist/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/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 "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-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/issuance/recover.d.ts

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

package/dist/issuance/recover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../src/issuance/recover.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,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAKpC,CAAC;AAkBH,wBAAgB,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAa9D"}

package/dist/issuance/recover.js

@@ -1,38 +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 "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-import { toHex } from "viem";
-export const RecoverErc20RequestSchema = z.object({
-    tokenAddress: AddressSchema,
-    from: AddressSchema,
-    to: AddressSchema,
-    amount: z.coerce.bigint().nonnegative(),
-});
-const recoverRoute = describeRoute({
-    summary: "Recover Gated ERC20",
-    description: "Returns transaction data for recovering a gated ERC20 token from one address to another",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for recovering a gated ERC20",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function recoverErc20(factory) {
-    return factory.createHandlers(recoverRoute, validator("json", RecoverErc20RequestSchema), async (c) => {
-        const { tokenAddress, from, to, amount } = c.req.valid("json");
-        return c.json(toTransaction({
-            address: tokenAddress,
-            abi: erc20GatedAbi,
-            functionName: "recover",
-            args: [from, to, toHex(amount)],
-        }));
-    });
-}

package/dist/issuance/renounceRole.d.ts

@@ -1,76 +0,0 @@
-import { z } from "zod";
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { Erc20GatedRole } from "../common/roles/erc20-gated-roles.js";
-export declare const RenounceRoleSchema: z.ZodObject<{
-    role: z.ZodNativeEnum<typeof Erc20GatedRole>;
-    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    address: `0x${string}`;
-    tokenAddress: `0x${string}`;
-    role: Erc20GatedRole;
-}, {
-    address: `0x${string}`;
-    tokenAddress: `0x${string}`;
-    role: Erc20GatedRole;
-}>;
-export declare function createRenounceRole<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            address: `0x${string}`;
-            tokenAddress: `0x${string}`;
-            role: Erc20GatedRole;
-        };
-    };
-    out: {
-        json: {
-            address: `0x${string}`;
-            tokenAddress: `0x${string}`;
-            role: Erc20GatedRole;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: 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}`;
-            tokenAddress: `0x${string}`;
-            role: Erc20GatedRole;
-        };
-    };
-    out: {
-        json: {
-            address: `0x${string}`;
-            tokenAddress: `0x${string}`;
-            role: Erc20GatedRole;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=renounceRole.d.ts.map

package/dist/issuance/renounceRole.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../src/issuance/renounceRole.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;AAGvC,OAAO,EAAqB,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAGzF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAO7B,CAAC;AAkBH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAepE"}

package/dist/issuance/renounceRole.js

@@ -1,42 +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 "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-import { convertRoleToHash, Erc20GatedRole } from "../common/roles/erc20-gated-roles.js";
-// Define the schema for the renounce role request
-export const RenounceRoleSchema = z.object({
-    role: z.nativeEnum(Erc20GatedRole).openapi({
-        description: "The role to renounce",
-        example: Erc20GatedRole.WHITELISTED_SPENDER_ROLE,
-    }),
-    address: AddressSchema.openapi("The address to renounce the role from"),
-    tokenAddress: AddressSchema.openapi("The address of the ERC20 token contract"),
-});
-const renounceRoleRoute = describeRoute({
-    summary: "Renounce Role to Address",
-    description: "Returns transaction data for renounce a role to an address",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for renounce a role",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function createRenounceRole(factory) {
-    return factory.createHandlers(renounceRoleRoute, validator("json", RenounceRoleSchema), async (c) => {
-        const { role, address, tokenAddress } = c.req.valid("json");
-        const roleHash = convertRoleToHash(role);
-        return c.json(toTransaction({
-            address: tokenAddress,
-            abi: erc20GatedAbi,
-            functionName: "renounceRole",
-            args: [roleHash, address],
-        }));
-    });
-}

package/dist/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, {
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    to: `0x${string}`;
-}, {
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    to: `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: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            to: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            to: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: 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: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            to: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            to: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=transfer.d.ts.map

package/dist/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/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 "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-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/issuance/upgrade.d.ts

@@ -1,82 +0,0 @@
-import { z } from "zod";
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare const UpgradeProxyRequestSchema: z.ZodObject<{
-    proxyAdminAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    proxyAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    newImplementation: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    data: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
-}, "strip", z.ZodTypeAny, {
-    newImplementation: `0x${string}`;
-    proxyAdminAddress: `0x${string}`;
-    proxyAddress: `0x${string}`;
-    data?: `0x${string}` | undefined;
-}, {
-    newImplementation: `0x${string}`;
-    proxyAdminAddress: `0x${string}`;
-    proxyAddress: `0x${string}`;
-    data?: `0x${string}` | undefined;
-}>;
-export declare function upgradeTransparentProxy<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            newImplementation: `0x${string}`;
-            proxyAdminAddress: `0x${string}`;
-            proxyAddress: `0x${string}`;
-            data?: `0x${string}` | undefined;
-        };
-    };
-    out: {
-        json: {
-            newImplementation: `0x${string}`;
-            proxyAdminAddress: `0x${string}`;
-            proxyAddress: `0x${string}`;
-            data?: `0x${string}` | undefined;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: 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: {
-            newImplementation: `0x${string}`;
-            proxyAdminAddress: `0x${string}`;
-            proxyAddress: `0x${string}`;
-            data?: `0x${string}` | undefined;
-        };
-    };
-    out: {
-        json: {
-            newImplementation: `0x${string}`;
-            proxyAdminAddress: `0x${string}`;
-            proxyAddress: `0x${string}`;
-            data?: `0x${string}` | undefined;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/issuance/upgrade.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/issuance/upgrade.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,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAapC,CAAC;AAmBH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAazE"}

package/dist/issuance/upgrade.js

@@ -1,45 +0,0 @@
-import { z } from "zod";
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { proxyAdminAbi } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
-export const UpgradeProxyRequestSchema = z.object({
-    proxyAdminAddress: AddressSchema.openapi({
-        description: "The address of the ProxyAdmin contract that manages the proxy",
-    }),
-    proxyAddress: AddressSchema.openapi({
-        description: "The address of the transparent proxy contract to upgrade",
-    }),
-    newImplementation: AddressSchema.openapi({
-        description: "The address of the new implementation contract",
-    }),
-    data: HexStringSchema.optional().openapi({
-        description: "Initialization data",
-    }),
-});
-const upgradeRoute = describeRoute({
-    summary: "Upgrade Transparent Proxy Implementation",
-    description: "Returns transaction data for upgrading the implementation of a transparent proxy contract using ProxyAdmin",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for upgrading transparent proxy implementation via ProxyAdmin",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function upgradeTransparentProxy(factory) {
-    return factory.createHandlers(upgradeRoute, validator("json", UpgradeProxyRequestSchema), async (c) => {
-        const { proxyAdminAddress, proxyAddress, newImplementation, data } = c.req.valid("json");
-        return c.json(toTransaction({
-            address: proxyAdminAddress,
-            abi: proxyAdminAbi,
-            functionName: "upgradeAndCall",
-            args: [proxyAddress, newImplementation, data || "0x"],
-        }));
-    });
-}

package/dist/package.json

@@ -1,78 +0,0 @@
-{
-    "name": "@evergonlabs/tmi-protocol-api",
-    "version": "0.1.0",
-    "license": "MIT",
-    "type": "module",
-    "exports": {
-        "./client": {
-            "import": "./dist/client.js",
-            "types": "./dist/client.d.ts",
-            "default": "./dist/client.cjs"
-        },
-        "./app": {
-            "import": "./dist/app.js",
-            "types": "./dist/app.d.ts",
-            "default": "./dist/app.cjs"
-        }
-    },
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "check-types": "tsc --noEmit",
-        "clean": "rimraf ./dist ./artifacts",
-        "docs:upload": "tsx ./scripts/generateAndUpload/bin.ts",
-        "lint": "eslint .",
-        "serve": "tsx ./src/serve.ts",
-        "build": "tsc -p tsconfig.build.json",
-        "test": "vitest run"
-    },
-    "dependencies": {
-        "@evergonlabs/tmi-protocol-fractions-sdk": "workspace:*",
-        "@evergonlabs/tmi-protocol-indexer": "workspace:*",
-        "@evergonlabs/tmi-protocol-shared": "workspace:*",
-        "@evergonlabs/tmi-protocol-staking-sdk": "workspace:*",
-        "@evergonlabs/tmi-protocol-types": "workspace:*",
-        "@evergonlabs/tmi-protocol-utils": "workspace:*",
-        "@evergonlabs/tmi-utils": "^0.2.0",
-        "@evergonlabs/tmi-evm-contracts": "0.3.4",
-        "@evergonlabs/token-library": "^0.1.0",
-        "@hono/node-server": "^1.13.8",
-        "@hono/swagger-ui": "^0.5.0",
-        "@hono/zod-openapi": "^0.18.4",
-        "@ponder/client": "^0.11.4",
-        "@quicknode/sdk": "^2.4.0",
-        "@scalar/hono-api-reference": "^0.5.170",
-        "abitype": "^1.0.8",
-        "axios": "^1.8.4",
-        "drizzle-orm": "0.41.0",
-        "hono": "^4.6.20",
-        "hono-openapi": "^0.4.4",
-        "type-fest": "^4.33.0",
-        "kysely": "^0.26.3",
-        "viem": "^2.23.2",
-        "zod": "^3.24.1",
-        "zod-openapi": "^4.2.3"
-    },
-    "devDependencies": {
-        "@evergonlabs/internal": "workspace:*",
-        "@evergonlabs/tmi-eslint-config": "^0.1.3",
-        "@evergonlabs/tmi-typescript-config": "^0.2.0",
-        "@topcli/prompts": "^2.1.0",
-        "dotenv": "^16.4.7",
-        "esbuild": "^0.25.0",
-        "eslint": "^9.21.0",
-        "execa": "^9.5.2",
-        "jiti": "^2.4.2",
-        "kleur": "^4.1.5",
-        "openapi-typescript": "^7.6.0",
-        "rdme": "^8.6.6",
-        "rimraf": "^6.0.1",
-        "tsx": "^4.19.2",
-        "typescript": "5.7.3",
-        "vitest": "^2.1.8"
-    },
-    "engines": {
-        "node": ">=18.14"
-    }
-}