@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/issuance/deploy.js

@@ -2,13 +2,13 @@ import { z } from "zod";
 import { encodeFunctionData } from "viem";
 import { describeRoute } from "hono-openapi";
 import { erc1967ProxyAbi, erc1967ProxyBytecode } from "@evergonlabs/tmi-evm-contracts/erc1967";
-import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-evm-contracts/transparentUpgradeableProxy";
+import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-protocol-contracts/transparentProxy";
 import { proxyAdminAbi, proxyAdminBytecode } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, HexStringSchema } from "../common/index.js";
-import { erc20GatedAbi, erc20GatedBytecode } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi, erc20GatedBytecode } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
+import { managedErc721Abi, managedErc721Bytecode } from "@evergonlabs/tmi-protocol-contracts/managedErc721";
 import { GATING_SIGNER_ADDRESS } from "./common.js";
-import * as erc721 from "@evergonlabs/tmi-evm-contracts/erc721";
 // Issue ERC20 Gated contract
 const IssuanceDeployErc20Schema = z
     .object({
@@ -53,12 +53,25 @@ const IssuanceDeployErc721Schema = z
 })
     .openapi({ ref: "IssuanceDeployErc721Schema" });
 const deployErc721Route = describeRoute({
-    summary: "Get ERC721",
-    description: "Returns transaction data for deploying an ERC721 contract",
+    summary: "Get Upgradeable ERC721 Implementation",
+    description: `Returns bytecode and ABI for deploying an upgradeable ManagedERC721 implementation contract.
+
+This is an upgradeable contract that should be deployed behind a TransparentUpgradeableProxy:
+1. Deploy implementation using the returned bytecode
+2. Get init data via POST /issuance/erc721/getInitData
+3. Deploy ProxyAdmin via GET /issuance/proxy/deployProxyAdmin
+4. Deploy TransparentUpgradeableProxy via POST /issuance/proxy/deployTransparentProxy
+
+Features:
+- mint(to, tokenId) - Mint token (MINTER_ROLE gated)
+- burn(tokenId) - Burn token (owner, approved, or MINTER_ROLE)
+- setBaseURI(uri) - Set base URI (URI_SETTER_ROLE gated)
+- setTokenURI(tokenId, uri) - Set token-specific URI (URI_SETTER_ROLE gated)
+- setContractURI(uri) - Set contract metadata URI (URI_SETTER_ROLE gated)`,
     tags: ["Issuance"],
     responses: {
         200: {
-            description: "Returns transaction data for deploying an ERC721 contract",
+            description: "Returns bytecode and ABI for deploying an upgradeable ERC721 implementation",
             content: {
                 "application/json": {
                     schema: resolver(IssuanceDeployErc721Schema),
@@ -70,8 +83,8 @@ const deployErc721Route = describeRoute({
 export function createErc721Token(factory) {
     return factory.createHandlers(deployErc721Route, async (c) => {
         return c.json({
-            bytecode: erc721.erc721Bytecode.object,
-            abi: erc721.erc721Abi,
+            bytecode: managedErc721Bytecode,
+            abi: managedErc721Abi,
         });
     });
 }

package/dist/issuance/erc20/approve.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const ApproveErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    spender: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const ApproveErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    spender: string;
+                    amount: 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=approve.d.ts.map

package/dist/issuance/erc20/approve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/approve.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}

package/dist/issuance/erc20/approve.js

@@ -0,0 +1,38 @@
+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";
+import { Int256BigInt } from "../../common/int256.js";
+export const ApproveErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    spender: AddressSchema,
+    amount: Int256BigInt(z.bigint().nonnegative()),
+});
+const approveRoute = describeRoute({
+    summary: "Approve Gated ERC20",
+    description: "Returns transaction data for approving spender to use a gated ERC20",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const ApproveErc20Token = createController({
+    build: (factory) => factory.createApp().post("/", approveRoute, validator("json", ApproveErc20RequestSchema), async (c) => {
+        const { tokenAddress, spender, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "approve",
+            args: [spender, BigInt(amount)],
+        }));
+    }),
+});

package/dist/issuance/erc20/burn.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const BurnErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    burnFrom: 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 BurnErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    amount: string;
+                    burnFrom: 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=burn.d.ts.map

package/dist/issuance/erc20/burn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/burn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;QAczB,CAAC"}

package/dist/issuance/erc20/burn.js

@@ -0,0 +1,38 @@
+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";
+import { Int256BigInt } from "../../common/int256.js";
+export const BurnErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    amount: Int256BigInt(z.bigint().nonnegative()),
+    burnFrom: AddressSchema,
+});
+const burnRoute = describeRoute({
+    summary: "Burn Gated ERC20",
+    description: "Returns transaction data for burning a gated ERC20",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for burning a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const BurnErc20Token = createController({
+    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc20RequestSchema), async (c) => {
+        const { tokenAddress, amount, burnFrom } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "burnFrom",
+            args: [burnFrom, BigInt(amount)],
+        }));
+    }),
+});

package/dist/issuance/erc20/deploy.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const DeployErc20RequestSchema: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    supplyCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    defaultTokenAdmin: 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 CreateErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    supplyCap: string;
+                    defaultTokenAdmin: 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=deploy.d.ts.map

package/dist/issuance/erc20/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB;;;;;;;iBAOnC,CAAC;AA2BH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAe3B,CAAC"}

package/dist/issuance/erc20/deploy.js

@@ -0,0 +1,52 @@
+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";
+import { Int256BigInt } from "../../common/int256.js";
+import { FactoryChainId, getFactories } from "../common/factories.js";
+export const DeployErc20RequestSchema = z.object({
+    chainId: FactoryChainId.Schema,
+    tokenName: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
+    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
+    supplyCap: Int256BigInt(z.bigint().nonnegative()),
+    defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+});
+const deployErc20Route = describeRoute({
+    summary: "Deploy ERC20 via Factory",
+    description: `Returns transaction data for deploying a new ERC20 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC20PausableRecoverableFactory to atomically deploy and initialize a new token proxy.
+
+The deployed token supports:
+- mint(to, amount) - Mint tokens (MINTER_ROLE gated)
+- burn(amount) - Burn tokens
+- burnFrom(account, amount) - Burn from account (with allowance)
+- pause() / unpause() - Pause/unpause transfers (PAUSER_ROLE gated)
+- recover(token, to, amount) - Recover tokens (RECOVER_ROLE gated)`,
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying an ERC20 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateErc20Token = createController({
+    build: (factory) => factory.createApp().post("/", deployErc20Route, validator("json", DeployErc20RequestSchema), async (c) => {
+        const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC20PausableRecoverableFactory,
+            abi: abis.erc20PausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [tokenName, tokenSymbol, BigInt(supplyCap), defaultTokenAdmin, minter],
+        }));
+    }),
+});

package/dist/issuance/erc20/deployGated.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const DeployGatedErc20RequestSchema: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    supplyCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    defaultTokenAdmin: 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}`>>;
+    gatingSigner: z.ZodOptional<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 CreateGatedErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    supplyCap: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            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=deployGated.d.ts.map

package/dist/issuance/erc20/deployGated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployGated.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deployGated.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,6BAA6B;;;;;;;;iBAUxC,CAAC;AAoBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyBhC,CAAC"}

package/dist/issuance/erc20/deployGated.js

@@ -0,0 +1,58 @@
+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";
+import { Int256BigInt } from "../../common/int256.js";
+import { DEFAULT_COMPILOT_SIGNER } from "../../common/models/compilot.js";
+import { FactoryChainId, getFactories } from "../common/factories.js";
+export const DeployGatedErc20RequestSchema = z.object({
+    chainId: FactoryChainId.Schema,
+    tokenName: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
+    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
+    supplyCap: Int256BigInt(z.bigint().nonnegative()),
+    defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+    gatingSigner: AddressSchema.optional().openapi({
+        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
+    }),
+});
+const deployGatedErc20Route = describeRoute({
+    summary: "Deploy Gated ERC20 via Factory",
+    description: `Returns transaction data for deploying a new whitelist-gated ERC20 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC20GatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy.`,
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a gated ERC20 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateGatedErc20Token = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", deployGatedErc20Route, validator("json", DeployGatedErc20RequestSchema), async (c) => {
+        const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC20GatedPausableRecoverableFactory,
+            abi: abis.erc20GatedPausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [
+                tokenName,
+                tokenSymbol,
+                BigInt(supplyCap),
+                defaultTokenAdmin,
+                minter,
+                gatingSigner ?? DEFAULT_COMPILOT_SIGNER,
+            ],
+        }));
+    }),
+});

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

@@ -0,0 +1,59 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "zod";
+export declare const Erc20InitDataResponse: z.ZodObject<{
+    data: 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 Erc20InitDataParams: z.ZodObject<{
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    cap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    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 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: {
+            tokenName: string;
+            tokenSymbol: string;
+            cap: string;
+            defaultAdmin: string;
+            minter: string;
+        };
+    };
+    out: {
+        json: {
+            tokenName: string;
+            tokenSymbol: string;
+            cap: bigint;
+            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: {
+            tokenName: string;
+            tokenSymbol: string;
+            cap: string;
+            defaultAdmin: string;
+            minter: string;
+        };
+    };
+    out: {
+        json: {
+            tokenName: string;
+            tokenSymbol: string;
+            cap: bigint;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=getInitData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/getInitData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,qBAAqB;;iBAIC,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;;;iBAQC,CAAC;AAkBlC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAaxE"}

package/dist/issuance/erc20/getInitData.js

@@ -0,0 +1,49 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { encodeFunctionData } from "viem";
+import { z } from "zod";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
+import { AddressSchema, DEFAULT_COMPILOT_SIGNER, HexStringSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+export const Erc20InitDataResponse = z
+    .object({
+    data: HexStringSchema.openapi("Init function call data in hex format"),
+})
+    .openapi("Erc20InitDataResponse");
+export const Erc20InitDataParams = z
+    .object({
+    tokenName: z.string().nonempty(),
+    tokenSymbol: z.string().nonempty(),
+    cap: Int256BigInt().openapi("Max. token supply"),
+    defaultAdmin: AddressSchema,
+    minter: AddressSchema,
+})
+    .openapi("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, DEFAULT_COMPILOT_SIGNER],
+        });
+        return c.json({
+            data: initData,
+        });
+    });
+}

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+export declare const GrantRoleErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    role: z.ZodEnum<typeof Erc20GatedRole>;
+    account: 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 GrantRoleErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: Erc20GatedRole;
+                    account: 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=grantRole.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,2BAA2B;;;;iBAOtC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;QAczB,CAAC"}

package/dist/issuance/erc20/grantRole.js

@@ -0,0 +1,41 @@
+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";
+import { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+export const GrantRoleErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    role: z.nativeEnum(Erc20GatedRole).openapi({
+        description: "The role to grant",
+        example: Erc20GatedRole.MINTER_ROLE,
+    }),
+    account: AddressSchema.openapi({ description: "The address to grant the role to" }),
+});
+const grantRoleRoute = describeRoute({
+    summary: "Grant Role on Gated ERC20",
+    description: "Returns transaction data for granting a role on a gated ERC20 token contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for granting a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const GrantRoleErc20 = createController({
+    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc20RequestSchema), async (c) => {
+        const { tokenAddress, role, account } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "grantRole",
+            args: [convertRoleToHash(role), account],
+        }));
+    }),
+});