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

package/dist/issuance/common/factories.d.ts

@@ -1,168 +1,3 @@
-export declare const FactoryChainId: {
-    Schema: import("zod").ZodUnion<[import("zod").ZodLiteral<11155111 | 72080>, import("zod").ZodLiteral<11155111 | 72080>, ...import("zod").ZodLiteral<11155111 | 72080>[]]>;
-    chains: ({
-        blockExplorers: {
-            readonly default: {
-                readonly name: "Etherscan";
-                readonly url: "https://sepolia.etherscan.io";
-                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
-            };
-        };
-        contracts: {
-            readonly multicall3: {
-                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-                readonly blockCreated: 751532;
-            };
-            readonly ensRegistry: {
-                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
-            };
-            readonly ensUniversalResolver: {
-                readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
-                readonly blockCreated: 5317080;
-            };
-        };
-        id: 11155111;
-        name: "Sepolia";
-        nativeCurrency: {
-            readonly name: "Sepolia Ether";
-            readonly symbol: "ETH";
-            readonly decimals: 18;
-        };
-        rpcUrls: {
-            readonly default: {
-                readonly http: readonly ["https://sepolia.drpc.org"];
-            };
-        };
-        sourceId?: number | undefined;
-        testnet: true;
-        custom?: Record<string, unknown> | undefined;
-        fees?: import("viem").ChainFees<undefined> | undefined;
-        formatters?: undefined;
-        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    } | {
-        blockExplorers: {
-            readonly default: {
-                readonly name: "Nexera Blockscout";
-                readonly url: "https://explorer.testnet.nexera.network/";
-            };
-        };
-        contracts: {};
-        id: 72080;
-        name: "Nexera Testnet";
-        nativeCurrency: {
-            readonly decimals: 18;
-            readonly name: "Nexera";
-            readonly symbol: "tNXRA";
-        };
-        rpcUrls: {
-            readonly default: {
-                readonly http: readonly ["https://rpc.testnet.nexera.network"];
-            };
-            readonly public: {
-                readonly http: readonly ["https://rpc.testnet.nexera.network"];
-            };
-        };
-        sourceId?: number | undefined | undefined;
-        testnet?: boolean | undefined | undefined;
-        custom?: Record<string, unknown> | undefined;
-        fees?: import("viem").ChainFees<undefined> | undefined;
-        formatters?: undefined;
-        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    })[];
-    chainIds: (11155111 | 72080)[];
-    isSupported: (chainId: number) => chainId is 11155111 | 72080;
-    get: <T extends 11155111 | 72080>(chainId: T) => Extract<{
-        blockExplorers: {
-            readonly default: {
-                readonly name: "Etherscan";
-                readonly url: "https://sepolia.etherscan.io";
-                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
-            };
-        };
-        contracts: {
-            readonly multicall3: {
-                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
-                readonly blockCreated: 751532;
-            };
-            readonly ensRegistry: {
-                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
-            };
-            readonly ensUniversalResolver: {
-                readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
-                readonly blockCreated: 5317080;
-            };
-        };
-        id: 11155111;
-        name: "Sepolia";
-        nativeCurrency: {
-            readonly name: "Sepolia Ether";
-            readonly symbol: "ETH";
-            readonly decimals: 18;
-        };
-        rpcUrls: {
-            readonly default: {
-                readonly http: readonly ["https://sepolia.drpc.org"];
-            };
-        };
-        sourceId?: number | undefined;
-        testnet: true;
-        custom?: Record<string, unknown> | undefined;
-        fees?: import("viem").ChainFees<undefined> | undefined;
-        formatters?: undefined;
-        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    }, {
-        id: T;
-    }> | Extract<{
-        blockExplorers: {
-            readonly default: {
-                readonly name: "Nexera Blockscout";
-                readonly url: "https://explorer.testnet.nexera.network/";
-            };
-        };
-        contracts: {};
-        id: 72080;
-        name: "Nexera Testnet";
-        nativeCurrency: {
-            readonly decimals: 18;
-            readonly name: "Nexera";
-            readonly symbol: "tNXRA";
-        };
-        rpcUrls: {
-            readonly default: {
-                readonly http: readonly ["https://rpc.testnet.nexera.network"];
-            };
-            readonly public: {
-                readonly http: readonly ["https://rpc.testnet.nexera.network"];
-            };
-        };
-        sourceId?: number | undefined | undefined;
-        testnet?: boolean | undefined | undefined;
-        custom?: Record<string, unknown> | undefined;
-        fees?: import("viem").ChainFees<undefined> | undefined;
-        formatters?: undefined;
-        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    }, {
-        id: T;
-    }>;
-};
+export { FactoryChainId, factoryChainIds, getFactories, type IFactoryChainId } from "./factories.base.js";
 export declare const FactoryChainIdQuery: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodUnion<[import("zod").ZodLiteral<11155111 | 72080>, import("zod").ZodLiteral<11155111 | 72080>, ...import("zod").ZodLiteral<11155111 | 72080>[]]>>;
-export declare const factoryChainIds: (11155111 | 72080)[];
-export type IFactoryChainId = (typeof factoryChainIds)[number];
-export declare function getFactories<T extends IFactoryChainId>(id: T): {
-    readonly DiamondFactory: "0x4be118d8a3a6f1490162e134E7419284827dbdBb";
-    readonly ERC1155GatedPausableRecoverableFactory: "0xe6727c1489F20a0b6d72A8D077BF14c7Ec495a94";
-    readonly ERC1155PausableRecoverableFactory: "0x14c2373FdE3a3dE21855376aF6420275cEB42320";
-    readonly ERC20GatedPausableRecoverableFactory: "0xee78B77c389770133573413A1606cA6db3941016";
-    readonly ERC20PausableRecoverableFactory: "0x2C81bb09947C16879f2a1C9380693FA628124515";
-    readonly ERC721GatedPausableRecoverableFactory: "0x04728c4C6130AB25844822F0ad940313daA5FF14";
-    readonly ERC721PausableRecoverableFactory: "0xA5048d05d8613db40C4eC0cFa08f9f1dCf916dDe";
-} | {
-    readonly DiamondFactory: "0x141c8f5BC8f7895E800518dc799f3D6e419b30Ac";
-    readonly ERC1155GatedPausableRecoverableFactory: "0xD21c194D6ac21A199223Aaa5d2b241a6f74117F0";
-    readonly ERC1155PausableRecoverableFactory: "0x5A981Bc93Bc434906C5DfbBb4B3fB7D0b8763854";
-    readonly ERC20GatedPausableRecoverableFactory: "0x12B91A2B8e99bf04C05885d71EB17d934d8c779d";
-    readonly ERC20PausableRecoverableFactory: "0xa66f033EB5C6D054cab1a2A41b39a1bDD9db2c16";
-    readonly ERC721GatedPausableRecoverableFactory: "0xd3b4B5f94f9E715987b5060a56C2575a56f5Bb08";
-    readonly ERC721PausableRecoverableFactory: "0xce97D17948bE18ef92490Da8AeB85c7ebC3c8694";
-};
 //# sourceMappingURL=factories.d.ts.map

package/dist/issuance/common/factories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../../src/issuance/common/factories.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAc2J,MAAgB;;6BAAyF,MAAgB,qCAAqC,MAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA9K,MAAgB;;6BAAyF,MAAgB,qCAAqC,MAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAdvR,CAAC;AAC9E,eAAO,MAAM,mBAAmB,wOAAsC,CAAC;AAEvE,eAAO,MAAM,eAAe,sBAAmF,CAAC;AAChH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,wBAAgB,YAAY,CAAC,CAAC,SAAS,eAAe,EAAE,EAAE,EAAE,CAAC;;;;;;;;;;;;;;;;EAO5D"}
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../../src/issuance/common/factories.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE1G,eAAO,MAAM,mBAAmB,wOAAsC,CAAC"}

package/dist/issuance/common/factories.js

@@ -1,17 +1,4 @@
-import { sepolia } from "viem/chains";
-import { constants } from "@evergonlabs/tmi-factories-sdk";
-import { nexeraTestnet } from "@evergonlabs/tmi-protocol-types/evm";
-import { createSupportedChains } from "@evergonlabs/tmi-utils/models";
-import { HttpError } from "../../common/http-error.js";
 import { createChainIdSchema } from "../../common/models/chainId.js";
-export const FactoryChainId = createSupportedChains([sepolia, nexeraTestnet]);
+import { FactoryChainId } from "./factories.base.js";
+export { FactoryChainId, factoryChainIds, getFactories } from "./factories.base.js";
 export const FactoryChainIdQuery = createChainIdSchema(FactoryChainId);
-export const factoryChainIds = FactoryChainId.chainIds;
-export function getFactories(id) {
-    if (id in constants.factoryAddresses) {
-        return constants.factoryAddresses[id];
-    }
-    throw new HttpError(400, {
-        message: "This chain id is not supported yet",
-    });
-}

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

@@ -28,5 +28,5 @@ export declare const ApproveErc20Token: import("../../common/controller.js").ICo
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=approve.d.ts.map

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

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

@@ -28,5 +28,5 @@ export declare const BurnErc20Token: import("../../common/controller.js").IContr
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=burn.d.ts.map

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc20/{deploy.d.ts → default/deploy.d.ts}

@@ -7,7 +7,7 @@ export declare const DeployErc20RequestSchema: z.ZodObject<{
     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, {
+export declare const CreateErc20Token: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
@@ -34,5 +34,5 @@ export declare const CreateErc20Token: import("../../common/controller.js").ICon
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=deploy.d.ts.map

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

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

package/dist/issuance/erc20/{deploy.js → default/deploy.js}

@@ -2,10 +2,10 @@ 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";
+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" }),
@@ -18,6 +18,8 @@ const deployErc20Route = describeRoute({
     summary: "Deploy ERC20 via Factory",
     description: `Returns transaction data for deploying a new ERC20 token via the factory contract.
 
+**Note: This contract is not audited.**
+
 Calls deployAndInitializeProxy on the ERC20PausableRecoverableFactory to atomically deploy and initialize a new token proxy.
 
 The deployed token supports:

package/dist/issuance/erc20/default/initialize.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const InitializeDefaultErc20RequestSchema: 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;
+    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 const InitializeDefaultErc20: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    name: string;
+                    symbol: string;
+                    cap: 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/erc20/default/initialize.d.ts.map

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

package/dist/issuance/erc20/default/initialize.js

@@ -0,0 +1,43 @@
+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 InitializeDefaultErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    name: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
+    symbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
+    cap: Int256BigInt(z.bigint().nonnegative()),
+    defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+});
+const initializeRoute = describeRoute({
+    summary: "Initialize ERC20",
+    description: "Returns transaction data for initializing an ERC20 token proxy contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for initializing an ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const InitializeDefaultErc20 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", initializeRoute, validator("json", InitializeDefaultErc20RequestSchema), async (c) => {
+        const { tokenAddress, name, symbol, cap, defaultAdmin, minter } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20PausableRecoverableUpgradeableAbi,
+            functionName: "initialize",
+            args: [name, symbol, BigInt(cap), defaultAdmin, minter],
+        }));
+    }),
+});

package/dist/issuance/erc20/default/parseDeployEvent.d.ts

@@ -0,0 +1,23 @@
+export declare const ParseDefaultErc20DeployEvent: 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}`;
+                supplyCap: string;
+                name: string;
+                symbol: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=parseDeployEvent.d.ts.map

package/dist/issuance/erc20/default/parseDeployEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/parseDeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;aAoDvC,CAAC"}

package/dist/issuance/erc20/{parseErc20DeployEvent.js → default/parseDeployEvent.js}

@@ -5,11 +5,11 @@ import { waitForTransactionReceipt } from "viem/actions";
 import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
-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";
+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: {
@@ -24,9 +24,9 @@ const QuerySchema = z.object({
         },
     }),
 });
-export const ParseErc20DeployEvent = createController({
+export const ParseDefaultErc20DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
-        summary: "Get TokenProxyConfigured Event",
+        summary: "Get ERC20 TokenProxyConfigured Event",
         description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the ERC20 factory \`deployAndInitializeProxy\` action`,
         tags: ["Issuance"],
         responses: {
@@ -52,12 +52,12 @@ export const ParseErc20DeployEvent = createController({
             hash: params.hash,
         });
         const [event] = parseEventLogs({
-            abi: abis.erc20GatedPausableRecoverableFactoryAbi,
+            abi: abis.erc20PausableRecoverableFactoryAbi,
             eventName: "TokenProxyConfigured",
             logs: receipt.logs,
         });
         if (!event) {
-            throw new UnableParseErc20DeployEvent();
+            throw new UnableParseDefaultErc20DeployEvent();
         }
         return c.json({
             proxy: event.args.proxy,
@@ -69,11 +69,11 @@ export const ParseErc20DeployEvent = createController({
         });
     }),
 });
-class UnableParseErc20DeployEvent extends HttpError {
+class UnableParseDefaultErc20DeployEvent extends HttpError {
     constructor() {
         super(500, {
             message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC20 factory \`deployAndInitializeProxy\` action`,
-            name: "UnableParseErc20DeployEvent",
+            name: "UnableParseDefaultErc20DeployEvent",
         });
     }
 }

package/dist/issuance/erc20/{deployGated.d.ts → gated/deploy.d.ts}

@@ -8,7 +8,7 @@ export declare const DeployGatedErc20RequestSchema: z.ZodObject<{
     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, {
+export declare const CreateGatedErc20Token: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
@@ -36,5 +36,5 @@ export declare const CreateGatedErc20Token: import("../../common/controller.js")
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
-//# sourceMappingURL=deployGated.d.ts.map
+}, "/", "/">>;
+//# sourceMappingURL=deploy.d.ts.map

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

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

package/dist/issuance/erc20/{deployGated.js → gated/deploy.js}

@@ -2,11 +2,11 @@ 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";
+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" }),
@@ -22,6 +22,8 @@ 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.
 
+**Note: This contract is not audited.**
+
 Calls deployAndInitializeProxy on the ERC20GatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy.`,
     tags: ["Issuance"],
     responses: {

package/dist/issuance/erc20/{initialize.d.ts → gated/initialize.d.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const InitializeErc20RequestSchema: z.ZodObject<{
+export declare const InitializeGatedErc20RequestSchema: 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;
@@ -8,7 +8,7 @@ export declare const InitializeErc20RequestSchema: z.ZodObject<{
     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 InitializeErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const InitializeGatedErc20: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
@@ -36,5 +36,5 @@ export declare const InitializeErc20: import("../../common/controller.js").ICont
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=initialize.d.ts.map

package/dist/issuance/erc20/gated/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,iCAAiC;;;;;;;;iBAU5C,CAAC;AAkBH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc/B,CAAC"}

package/dist/issuance/erc20/{initialize.js → gated/initialize.js}

@@ -2,11 +2,11 @@ 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";
-export const InitializeErc20RequestSchema = z.object({
+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";
+export const InitializeGatedErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
     symbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
@@ -32,8 +32,8 @@ const initializeRoute = describeRoute({
         },
     },
 });
-export const InitializeErc20 = createController({
-    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc20RequestSchema), async (c) => {
+export const InitializeGatedErc20 = createController({
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeGatedErc20RequestSchema), async (c) => {
         const { tokenAddress, name, symbol, cap, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/erc20/{parseErc20DeployEvent.d.ts → gated/parseDeployEvent.d.ts}

@@ -1,4 +1,4 @@
-export declare const ParseErc20DeployEvent: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const ParseGatedErc20DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {
             input: {
@@ -19,5 +19,5 @@ export declare const ParseErc20DeployEvent: import("../../common/controller.js")
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
-//# sourceMappingURL=parseErc20DeployEvent.d.ts.map
+}, "/", "/">>;
+//# sourceMappingURL=parseDeployEvent.d.ts.map

package/dist/issuance/erc20/gated/parseDeployEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/parseDeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;aAoDrC,CAAC"}