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

package/dist/fractions/sales/rejectFractions.js

@@ -12,7 +12,7 @@ export const RejectFractionsRequestSchema = z.object({
 const route = describeRoute({
     summary: "Reject fractions",
     description: "Returns transaction data for rejecting fractions in a sale",
-    tags: ["Fractions"],
+    tags: ["Sales"],
     responses: {
         200: {
             description: "Returns transaction data for rejecting fractions",

package/dist/fractions/sales/searchActivity.route.js

@@ -13,7 +13,7 @@ export const SearchActivityV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search activity events",
         description: "Search activity events by users, platforms and pools",
-        tags: ["Fractions"],
+        tags: ["Sales"],
         responses: {
             200: {
                 description: "Returns list of activity events within specified platforms and pools",

package/dist/fractions/sales/searchSales/searchSales.js

@@ -11,7 +11,7 @@ export const SearchSalesV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search sale events",
         description: "Search sale events by users, platforms and pools",
-        tags: ["Fractions"],
+        tags: ["Sales"],
         responses: {
             200: {
                 description: "Returns list of sales events within specified platforms and pools",

package/dist/fractions/sales/searchWithdrawal.route.js

@@ -11,7 +11,7 @@ export const SearchWithdrawalV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search withdrawal events",
         description: "Search withdrawal events by users, platforms and pools",
-        tags: ["Fractions"],
+        tags: ["Sales"],
         responses: {
             200: {
                 description: "Returns list of withdrawal events within specified platforms and pools",

package/dist/fractions/sales/setFeeCapLimit.js

@@ -13,7 +13,7 @@ export const SetFeeCapLimitRequestSchema = z.object({
 const route = describeRoute({
     summary: "Set fee cap limit",
     description: "Returns transaction data for setting the fee cap limit",
-    tags: ["Fractions"],
+    tags: ["Sales"],
     responses: {
         200: {
             description: "Returns transaction data for setting the fee cap limit",

package/dist/fractions/sales/unlockWrappedAssets.route.js

@@ -7,7 +7,7 @@ export const UnlockWrappedAssetsRequestSchema = SaleIdSchema;
 const route = describeRoute({
     summary: "Unlock wrapped assets from a non-funded sale",
     description: "Returns transaction to unlock wrapped assets from a non-funded sale",
-    tags: ["Fractions"],
+    tags: ["Sales"],
     responses: {
         200: {
             description: "Returns transaction to unlock wrapped assets from a non-funded sale",

package/dist/fractions/sales/vesting/claimStatistics.route.js

@@ -33,7 +33,7 @@ export const ClaimStatisticsV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Get claim statistics for a vesting campaign",
         description: "Retrieves the total number of claims made and the last claim ID for a specific vesting campaign and wallet address",
-        tags: ["Fractions Vesting"],
+        tags: ["Vesting"],
         responses: {
             200: {
                 description: "Returns claim statistics for the specified campaign and wallet address",

package/dist/fractions/sales/vesting/claimVestedTokens.route.js

@@ -14,7 +14,7 @@ export const ClaimVestedTokensRequestSchema = z.object({
 const route = describeRoute({
     summary: "Claim vested tokens",
     description: "Returns transaction data for claiming vested tokens from a campaign",
-    tags: ["Fractions Vesting"],
+    tags: ["Vesting"],
     responses: {
         200: {
             description: "Returns transaction data for claiming vested tokens",

package/dist/fractions/sales/vesting/editCliff.route.js

@@ -14,7 +14,7 @@ export const EditCliffRequestSchema = z.object({
 const route = describeRoute({
     summary: "Edit the cliff of a vesting schedule",
     description: "Returns transaction data for updating the cliff date in a vesting schedule",
-    tags: ["Fractions Vesting"],
+    tags: ["Vesting"],
     responses: {
         200: {
             description: "Returns transaction data for editing the cliff date",

package/dist/fractions/sales/vesting/parseClaimVestedTokensEvent.js

@@ -12,7 +12,7 @@ export const ParseClaimVestedTokensEventV0 = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get ClaimVestedTokens Event",
         description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`claimVestedTokens\` action`,
-        tags: ["Fractions Vesting"],
+        tags: ["Vesting"],
         responses: {
             200: {
                 description: "Returns parsed event log",

package/dist/fractions/sales/withdraw.route.js

@@ -7,7 +7,7 @@ export const WithdrawRequestSchema = SaleIdSchema;
 const route = describeRoute({
     summary: "Withdraw payment tokens from a sale",
     description: "Returns transaction to withdraw payment tokens from a sale",
-    tags: ["Fractions"],
+    tags: ["Sales"],
     responses: {
         200: {
             description: "Returns transaction to withdraw payment tokens from a sale",

package/dist/fractions/statistics/networkStatistics.route.js

@@ -102,7 +102,7 @@ export const GetHoldersV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Get number of fraction holders",
         description: `Returns the count of unique wallet addresses that hold fractions from successful (finalized) sales. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations.`,
-        tags: ["RWA Statistics"],
+        tags: ["Statistics"],
         responses: {
             200: {
                 description: "Number of unique fraction holders",
@@ -128,7 +128,7 @@ export const GetSalesStatisticsV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Get number of successful sales",
         description: `Returns the count of successful (finalized) fraction sales representing RWA tokens. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations.`,
-        tags: ["RWA Statistics"],
+        tags: ["Statistics"],
         responses: {
             200: {
                 description: "Number of successful fraction sales",
@@ -154,7 +154,7 @@ export const GetTtvV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Get Total Tokenized Value (TTV)",
         description: `Returns the Total Tokenized Value - the sum of all amounts raised by successful (finalized) sales in USDC. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations.`,
-        tags: ["RWA Statistics"],
+        tags: ["Statistics"],
         responses: {
             200: {
                 description: "Total Tokenized Value in USDC",
@@ -195,7 +195,7 @@ export const GetNetworkStatisticsV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Get all network statistics",
         description: `Returns all network statistics in a single call: number of fraction holders, successful sales count, and TTV. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations like RWA.XYZ.`,
-        tags: ["RWA Statistics"],
+        tags: ["Statistics"],
         responses: {
             200: {
                 description: "Network statistics including holders, sales, and TTV",

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

@@ -149,19 +149,19 @@ 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: "0x52DEA561a81E4AAC451431F2d9E88ACb1e31C520";
-    readonly ERC1155PausableRecoverableFactory: "0x39F9AD5A2F869b22e84bDCC27C246dA4F34f5cD6";
-    readonly ERC20GatedPausableRecoverableFactory: "0xcDb88041351f6c3008D4bb5b403A16EA26a382d3";
-    readonly ERC20PausableRecoverableFactory: "0xddA13D3F875Ee039b18de8d4C0Fda96c045299B2";
-    readonly ERC721GatedPausableRecoverableFactory: "0xBd79C0E23E69Da284378188015d85f5C0196DF05";
-    readonly ERC721PausableRecoverableFactory: "0x22F97529FAA6ECb6306C0cd274E8F1a851A31Dc3";
+    readonly ERC1155AutoIdGatedPausableRecoverableFactory: "0xc29A12b1dF6f6F285f66fdd879b2feBc50a3bbEf";
+    readonly ERC1155AutoIdPausableRecoverableFactory: "0xAc373c72e4683F8eFc5303d060703a480bfAA74A";
+    readonly ERC20GatedPausableRecoverableFactory: "0x95E521FEe12cc5b551151C94f8d146B9C7f043fA";
+    readonly ERC20PausableRecoverableFactory: "0xFea92aC14C5B39590b29C86370D0A710aE02B45D";
+    readonly ERC721AutoIdGatedPausableRecoverableFactory: "0xdB2b8eB6df1C89C1887ad9A38938153cc896AB37";
+    readonly ERC721AutoIdPausableRecoverableFactory: "0xFE98EF8Ba0f70f59D18862F2528071F00A94f0C3";
 } | {
     readonly DiamondFactory: "0x141c8f5BC8f7895E800518dc799f3D6e419b30Ac";
-    readonly ERC1155GatedPausableRecoverableFactory: "0xBa362eeAc702C32935601Ea13063f6ECde1AbF14";
-    readonly ERC1155PausableRecoverableFactory: "0x6B194C183dB881c4Fcc95a6fC4eA6a47d062256c";
-    readonly ERC20GatedPausableRecoverableFactory: "0xc0E81eA6bC7eCc3639e550b5Ff5e3B840A0B151f";
-    readonly ERC20PausableRecoverableFactory: "0x48711c8E26f1a658f58B6d426cd7Be52de02ffF9";
-    readonly ERC721GatedPausableRecoverableFactory: "0x43C8BfbAB561D406F362e0cCc75EB9FbCc6ebc2e";
-    readonly ERC721PausableRecoverableFactory: "0x0F48421Ac48D921A1513e50dd8eBbFBbF18e58eE";
+    readonly ERC1155AutoIdGatedPausableRecoverableFactory: "0x059A29005D665134a2BDe3828053dA09C0423E68";
+    readonly ERC1155AutoIdPausableRecoverableFactory: "0xDf10CF08E8362d8185C3bb148DdCf9aB8e8F5D16";
+    readonly ERC20GatedPausableRecoverableFactory: "0x969Ef79EeecA0A647ae975561014351767afa155";
+    readonly ERC20PausableRecoverableFactory: "0x868d1414BAc904175ba9c905EeE38150BDE34eBb";
+    readonly ERC721AutoIdGatedPausableRecoverableFactory: "0x0fee6C8Cde9Ab6C59DA9a6b19127b9e616D7bE49";
+    readonly ERC721AutoIdPausableRecoverableFactory: "0x0d6E0315119DBE67F717F76B75f2A0FBd8FF3858";
 };
 //# sourceMappingURL=factories.base.d.ts.map

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/burn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAC;AAkBH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;aActB,CAAC"}

package/dist/issuance/erc1155/burn.js

@@ -0,0 +1,40 @@
+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 { erc1155Tag } from "./tag.js";
+export const BurnErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    account: AddressSchema.openapi({ description: "Address to burn tokens from" }),
+    id: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Token ID to burn" }),
+    amount: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Amount of tokens to burn" }),
+});
+const burnRoute = describeRoute({
+    summary: "Burn ERC1155",
+    description: "Returns transaction data for burning an ERC1155 token",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for burning an ERC1155 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const BurnErc1155 = createController({
+    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc1155RequestSchema), async (c) => {
+        const { tokenAddress, account, id, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdPausableRecoverableUpgradeableAbi,
+            functionName: "burn",
+            args: [account, BigInt(id), BigInt(amount)],
+        }));
+    }),
+});

package/dist/issuance/erc1155/default/deploy.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const DeployErc1155RequestSchema: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    baseURI: z.ZodString;
+    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 CreateErc1155Token: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    baseURI: 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/erc1155/default/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AA+BH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc1155/default/deploy.js

@@ -0,0 +1,54 @@
+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 { FactoryChainId, getFactories } from "../../common/factories.js";
+import { erc1155Tag } from "../tag.js";
+export const DeployErc1155RequestSchema = z.object({
+    chainId: FactoryChainId.Schema,
+    baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
+    defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+});
+const deployErc1155Route = describeRoute({
+    summary: "Deploy ERC1155 via Factory",
+    description: `This contract has not been audited.
+
+Returns transaction data for deploying a new ERC1155 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC1155AutoIdPausableRecoverableFactory to atomically deploy and initialize a new token proxy.
+
+The deployed token supports:
+- mint(to, amount, data) - Mint tokens with auto-generated ID (MINTER_ROLE gated)
+- mintBatch(to, amounts, data) - Mint multiple tokens with auto-generated IDs (MINTER_ROLE gated)
+- burn(account, id, amount) - Burn tokens
+- burnBatch(account, ids, amounts) - Burn multiple tokens
+- setURI(newuri) - Set metadata URI (DEFAULT_ADMIN_ROLE gated)
+- pause() / unpause() - Pause/unpause transfers (PAUSER_ROLE gated)
+- recover(token, to, amount) - Recover tokens (RECOVER_ROLE gated)`,
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying an ERC1155 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateErc1155Token = createController({
+    build: (factory) => factory.createApp().post("/", deployErc1155Route, validator("json", DeployErc1155RequestSchema), async (c) => {
+        const { chainId, baseURI, defaultTokenAdmin, minter } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC1155AutoIdPausableRecoverableFactory,
+            abi: abis.erc1155AutoIdPausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [baseURI, defaultTokenAdmin, minter],
+        }));
+    }),
+});

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const InitializeErc1155RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    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 InitializeDefaultErc1155: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: 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/erc1155/default/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAkBH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;aAcnC,CAAC"}

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

@@ -0,0 +1,39 @@
+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 { erc1155Tag } from "../tag.js";
+export const InitializeErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    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 ERC1155",
+    description: "Returns transaction data for initializing an ERC1155 token proxy contract",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for initializing an ERC1155 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const InitializeDefaultErc1155 = createController({
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc1155RequestSchema), async (c) => {
+        const { tokenAddress, baseURI, defaultAdmin, minter } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdPausableRecoverableUpgradeableAbi,
+            functionName: "initialize",
+            args: [baseURI, defaultAdmin, minter],
+        }));
+    }),
+});

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

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

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

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

package/dist/issuance/erc1155/default/parseDeployEvent.js

@@ -0,0 +1,75 @@
+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";
+import { erc1155Tag } from "../tag.js";
+const QuerySchema = z.object({
+    chainId: FactoryChainIdQuery.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    hash: HashSchema.openapi({
+        param: {
+            name: "hash",
+            in: "query",
+        },
+    }),
+});
+export const ParseDefaultErc1155DeployEvent = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get ERC1155 TokenProxyConfigured Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the ERC1155 factory \`deployAndInitializeProxy\` action`,
+        tags: [erc1155Tag.tag],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            proxy: AddressSchema,
+                            admin: AddressSchema,
+                            minter: AddressSchema,
+                            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.erc1155AutoIdPausableRecoverableFactoryAbi,
+            eventName: "TokenProxyConfigured",
+            logs: receipt.logs,
+        });
+        if (!event) {
+            throw new UnableParseDefaultErc1155DeployEvent();
+        }
+        return c.json({
+            proxy: event.args.proxy,
+            admin: event.args.admin,
+            minter: event.args.minter,
+            baseURI: event.args.baseURI,
+        });
+    }),
+});
+class UnableParseDefaultErc1155DeployEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC1155 factory \`deployAndInitializeProxy\` action`,
+            name: "UnableParseDefaultErc1155DeployEvent",
+        });
+    }
+}

package/dist/issuance/erc1155/gated/deploy.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const DeployGatedErc1155RequestSchema: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    baseURI: z.ZodString;
+    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 CreateGatedErc1155Token: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    baseURI: 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=deploy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,+BAA+B;;;;;;iBAQ1C,CAAC;AAiCH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBlC,CAAC"}