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

package/dist/issuance/erc721/getInitData.js

@@ -1,51 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { encodeFunctionData } from "viem";
-import z from "zod";
-import { managedErc721Abi } from "@evergonlabs/tmi-protocol-contracts/managedErc721";
-import { AddressSchema, HexStringSchema } from "../../common/index.js";
-export const Erc721InitDataResponse = z
-    .object({
-    data: HexStringSchema.openapi("Init function call data in hex format"),
-})
-    .openapi("Erc721InitDataResponse");
-export const Erc721InitDataParams = z
-    .object({
-    tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
-    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
-    admin: AddressSchema.openapi({
-        description: "Address to receive DEFAULT_ADMIN_ROLE, MINTER_ROLE, and URI_SETTER_ROLE",
-    }),
-})
-    .openapi("ERC721InitDataParams");
-const getErc721InitDataRoute = describeRoute({
-    summary: "Get ERC721 Init Data",
-    description: `Returns initialize function call data in hex format for ManagedERC721Upgradeable.
-
-This is useful for providing initData when deploying a TransparentUpgradeableProxy.
-The admin address receives DEFAULT_ADMIN_ROLE, MINTER_ROLE, and URI_SETTER_ROLE.`,
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Init function call data in hex format",
-            content: {
-                "application/json": {
-                    schema: resolver(Erc721InitDataResponse),
-                },
-            },
-        },
-    },
-});
-export function createGetErc721InitData(factory) {
-    return factory.createHandlers(getErc721InitDataRoute, validator("json", Erc721InitDataParams), async (c) => {
-        const data = c.req.valid("json");
-        const initData = encodeFunctionData({
-            abi: managedErc721Abi,
-            functionName: "initialize",
-            args: [data.tokenName, data.tokenSymbol, data.admin],
-        });
-        return c.json({
-            data: initData,
-        });
-    });
-}

package/dist/issuance/erc721/initialize.d.ts

@@ -1,38 +0,0 @@
-import { z } from "zod";
-export declare const InitializeErc721RequestSchema: z.ZodObject<{
-    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    name: z.ZodString;
-    symbol: z.ZodString;
-    baseURI: z.ZodString;
-    defaultAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-}, z.core.$strip>;
-export declare const InitializeErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    tokenAddress: string;
-                    name: string;
-                    symbol: string;
-                    baseURI: string;
-                    defaultAdmin: string;
-                    minter: 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;
-        };
-    };
-}, "/">>;
-//# sourceMappingURL=initialize.d.ts.map

package/dist/issuance/erc721/initialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,6BAA6B;;;;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAc3B,CAAC"}

package/dist/issuance/erc721/initialize.js

@@ -1,40 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
-import { abis } from "@evergonlabs/tmi-factories-sdk";
-import { createController } from "../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const InitializeErc721RequestSchema = z.object({
-    tokenAddress: AddressSchema,
-    name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
-    symbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
-    baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
-    defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
-    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
-const initializeRoute = describeRoute({
-    summary: "Initialize ERC721",
-    description: "Returns transaction data for initializing an ERC721 token proxy contract",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for initializing an ERC721 token",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export const InitializeErc721 = createController({
-    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc721RequestSchema), async (c) => {
-        const { tokenAddress, name, symbol, baseURI, defaultAdmin, minter } = c.req.valid("json");
-        return c.json(toTransaction({
-            address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
-            functionName: "initialize",
-            args: [name, symbol, baseURI, defaultAdmin, minter],
-        }));
-    }),
-});

package/dist/issuance/erc721/parseErc721DeployEvent.d.ts

@@ -1,23 +0,0 @@
-export declare const ParseErc721DeployEvent: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
-    "/": {
-        $get: {
-            input: {
-                query: {
-                    chainId: string | string[];
-                    hash: string | string[];
-                };
-            };
-            output: {
-                proxy: `0x${string}`;
-                admin: `0x${string}`;
-                minter: `0x${string}`;
-                name: string;
-                symbol: string;
-                baseURI: string;
-            };
-            outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
-        };
-    };
-}, "/">>;
-//# sourceMappingURL=parseErc721DeployEvent.d.ts.map

package/dist/issuance/erc721/parseErc721DeployEvent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseErc721DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/parseErc721DeployEvent.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;QAoDjC,CAAC"}

package/dist/issuance/erc721/parseErc721DeployEvent.js

@@ -1,78 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { parseEventLogs } from "viem";
-import { waitForTransactionReceipt } from "viem/actions";
-import { z } from "zod";
-import { abis } from "@evergonlabs/tmi-factories-sdk";
-import { getPublicClient } from "../../common/blockchain.js";
-import { createController } from "../../common/controller.js";
-import { HttpError } from "../../common/http-error.js";
-import { AddressSchema, HashSchema } from "../../common/index.js";
-import { FactoryChainIdQuery } from "../common/factories.js";
-const QuerySchema = z.object({
-    chainId: FactoryChainIdQuery.openapi({
-        param: {
-            name: "chainId",
-            in: "query",
-        },
-    }),
-    hash: HashSchema.openapi({
-        param: {
-            name: "hash",
-            in: "query",
-        },
-    }),
-});
-export const ParseErc721DeployEvent = createController({
-    build: (factory) => factory.createApp().get("/", describeRoute({
-        summary: "Get ERC721 TokenProxyConfigured Event",
-        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the ERC721 factory \`deployAndInitializeProxy\` action`,
-        tags: ["Issuance"],
-        responses: {
-            200: {
-                description: "Returns parsed event log",
-                content: {
-                    "application/json": {
-                        schema: resolver(z.object({
-                            proxy: AddressSchema,
-                            admin: AddressSchema,
-                            minter: AddressSchema,
-                            name: z.string(),
-                            symbol: z.string(),
-                            baseURI: z.string(),
-                        })),
-                    },
-                },
-            },
-        },
-    }), validator("query", QuerySchema), async (c) => {
-        const params = c.req.valid("query");
-        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
-            hash: params.hash,
-        });
-        const [event] = parseEventLogs({
-            abi: abis.erc721GatedPausableRecoverableFactoryAbi,
-            eventName: "TokenProxyConfigured",
-            logs: receipt.logs,
-        });
-        if (!event) {
-            throw new UnableParseErc721DeployEvent();
-        }
-        return c.json({
-            proxy: event.args.proxy,
-            admin: event.args.admin,
-            minter: event.args.minter,
-            name: event.args.name,
-            symbol: event.args.symbol,
-            baseURI: event.args.baseURI,
-        });
-    }),
-});
-class UnableParseErc721DeployEvent extends HttpError {
-    constructor() {
-        super(500, {
-            message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC721 factory \`deployAndInitializeProxy\` action`,
-            name: "UnableParseErc721DeployEvent",
-        });
-    }
-}

package/dist/issuance/getInitData.d.ts

@@ -1,132 +0,0 @@
-import z from "zod";
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare const Erc20InitDataResponse: z.ZodObject<{
-    data: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    data: `0x${string}`;
-}, {
-    data: `0x${string}`;
-}>;
-export declare const Erc20InitDataParams: z.ZodObject<{
-    tokenName: z.ZodString;
-    tokenSymbol: z.ZodString;
-    cap: z.ZodPipeline<z.ZodString, z.ZodBigInt>;
-    defaultAdmin: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    minter: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    cap: bigint;
-    tokenName: string;
-    tokenSymbol: string;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
-}, {
-    cap: string;
-    tokenName: string;
-    tokenSymbol: string;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
-}>;
-export declare function createGetErc20InitData<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            cap: string;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            cap: bigint;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, 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: {
-            cap: string;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            cap: bigint;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-export declare const Erc721InitDataResponse: z.ZodObject<{
-    data: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    data: `0x${string}`;
-}, {
-    data: `0x${string}`;
-}>;
-export declare const Erc721InitDataParams: z.ZodObject<{
-    tokenName: z.ZodString;
-    tokenSymbol: z.ZodString;
-    admin: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    admin: `0x${string}`;
-    tokenName: string;
-    tokenSymbol: string;
-}, {
-    admin: `0x${string}`;
-    tokenName: string;
-    tokenSymbol: string;
-}>;
-export declare function createGetErc721InitData<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            admin: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-    out: {
-        json: {
-            admin: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, 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: {
-            admin: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-    out: {
-        json: {
-            admin: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=getInitData.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../src/issuance/getInitData.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAQvC,eAAO,MAAM,qBAAqB;;;;;;EAM9B,CAAC;AAEL,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAU5B,CAAC;AAkBL,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAaxE;AAID,eAAO,MAAM,sBAAsB;;;;;;EAM/B,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAU7B,CAAC;AAqBL,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAazE"}

package/dist/issuance/getInitData.js

@@ -1,104 +0,0 @@
-import z from "zod";
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { encodeFunctionData } from "viem";
-import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-import { managedErc721Abi } from "@evergonlabs/tmi-protocol-contracts/managedErc721";
-import { AddressSchema, HexStringSchema } from "../common/index.js";
-import { GATING_SIGNER_ADDRESS } from "./common.js";
-export const Erc20InitDataResponse = z
-    .object({
-    data: HexStringSchema.openapi("Init function call data in hex format"),
-})
-    .openapi({
-    ref: "Erc20InitDataResponse",
-});
-export const Erc20InitDataParams = z
-    .object({
-    tokenName: z.string().nonempty(),
-    tokenSymbol: z.string().nonempty(),
-    cap: z.string().pipe(z.coerce.bigint().nonnegative()).openapi("Max. token supply"),
-    defaultAdmin: AddressSchema,
-    minter: AddressSchema,
-})
-    .openapi({
-    ref: "ERC20InitDataParams",
-});
-const getErc20InitDataRoute = describeRoute({
-    summary: "Get ERC20 Init Data",
-    description: `Returns init function call data in hex format. This is useful for using as initData in TransparentUpgradeableProxy`,
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Init function call data in hex format",
-            content: {
-                "application/json": {
-                    schema: resolver(Erc20InitDataResponse),
-                },
-            },
-        },
-    },
-});
-export function createGetErc20InitData(factory) {
-    return factory.createHandlers(getErc20InitDataRoute, validator("json", Erc20InitDataParams), async (c) => {
-        const data = c.req.valid("json");
-        const initData = encodeFunctionData({
-            abi: erc20GatedAbi,
-            functionName: "init",
-            args: [data.tokenName, data.tokenSymbol, data.cap, data.defaultAdmin, data.minter, GATING_SIGNER_ADDRESS],
-        });
-        return c.json({
-            data: initData,
-        });
-    });
-}
-// ERC721 Init Data
-export const Erc721InitDataResponse = z
-    .object({
-    data: HexStringSchema.openapi("Init function call data in hex format"),
-})
-    .openapi({
-    ref: "Erc721InitDataResponse",
-});
-export const Erc721InitDataParams = z
-    .object({
-    tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
-    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
-    admin: AddressSchema.openapi({
-        description: "Address to receive DEFAULT_ADMIN_ROLE, MINTER_ROLE, and URI_SETTER_ROLE",
-    }),
-})
-    .openapi({
-    ref: "ERC721InitDataParams",
-});
-const getErc721InitDataRoute = describeRoute({
-    summary: "Get ERC721 Init Data",
-    description: `Returns initialize function call data in hex format for ManagedERC721Upgradeable.
-  
-This is useful for providing initData when deploying a TransparentUpgradeableProxy.
-The admin address receives DEFAULT_ADMIN_ROLE, MINTER_ROLE, and URI_SETTER_ROLE.`,
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Init function call data in hex format",
-            content: {
-                "application/json": {
-                    schema: resolver(Erc721InitDataResponse),
-                },
-            },
-        },
-    },
-});
-export function createGetErc721InitData(factory) {
-    return factory.createHandlers(getErc721InitDataRoute, validator("json", Erc721InitDataParams), async (c) => {
-        const data = c.req.valid("json");
-        const initData = encodeFunctionData({
-            abi: managedErc721Abi,
-            functionName: "initialize",
-            args: [data.tokenName, data.tokenSymbol, data.admin],
-        });
-        return c.json({
-            data: initData,
-        });
-    });
-}

package/dist/issuance/grantRole.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 GrantRoleSchema: 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 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: {
-        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=grantRole.d.ts.map

package/dist/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;AAGvC,OAAO,EAAqB,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAGzF,eAAO,MAAM,eAAe;;;;;;;;;;;;EAO1B,CAAC;AAkBH,wBAAgB,eAAe,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAejE"}

package/dist/issuance/grantRole.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 grant role request
-export const GrantRoleSchema = z.object({
-    role: z.nativeEnum(Erc20GatedRole).openapi({
-        description: "The role to grant to the address",
-        example: Erc20GatedRole.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/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, {
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    mintTo: `0x${string}`;
-}, {
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    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: {
-        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;
-            mintTo: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            mintTo: `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;
-            mintTo: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            mintTo: `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=mint.d.ts.map