@evergonlabs/tmi-protocol-api 0.1.0

package/dist/src/fractions/createFractions/v0/createFractions.schema.d.ts

@@ -0,0 +1,416 @@
+import { z } from "zod";
+export declare const TimeBoundarySchema: z.ZodObject<{
+    start: z.ZodDate;
+    end: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    start: Date;
+    end: Date;
+}, {
+    start: Date;
+    end: Date;
+}>;
+export declare const CapitalizationSchema: z.ZodObject<{
+    soft: z.ZodBigInt;
+    hard: z.ZodBigInt;
+    softPerAccount: z.ZodOptional<z.ZodBigInt>;
+    hardPerAccount: z.ZodOptional<z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    soft: bigint;
+    hard: bigint;
+    softPerAccount?: bigint | undefined;
+    hardPerAccount?: bigint | undefined;
+}, {
+    soft: bigint;
+    hard: bigint;
+    softPerAccount?: bigint | undefined;
+    hardPerAccount?: bigint | undefined;
+}>;
+export declare const ERC20TokenSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ERC20">;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    values: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    values: [bigint, ...bigint[]];
+    type: "ERC20";
+    address: `0x${string}`;
+}, {
+    values: [bigint, ...bigint[]];
+    type: "ERC20";
+    address: `0x${string}`;
+}>;
+export declare const ERC721TokenSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ERC721">;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    type: "ERC721";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}, {
+    type: "ERC721";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}>;
+export declare const ERC1155TokenSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ERC1155">;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+    values: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    values: [bigint, ...bigint[]];
+    type: "ERC1155";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}, {
+    values: [bigint, ...bigint[]];
+    type: "ERC1155";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}>;
+export declare const WrappedTokenTypeSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"ERC20">;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    values: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    values: [bigint, ...bigint[]];
+    type: "ERC20";
+    address: `0x${string}`;
+}, {
+    values: [bigint, ...bigint[]];
+    type: "ERC20";
+    address: `0x${string}`;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ERC721">;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    type: "ERC721";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}, {
+    type: "ERC721";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ERC1155">;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+    values: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    values: [bigint, ...bigint[]];
+    type: "ERC1155";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}, {
+    values: [bigint, ...bigint[]];
+    type: "ERC1155";
+    address: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}>]>;
+export declare const FundingSchema: z.ZodObject<{
+    token: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountPerPacket: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    token: `0x${string}`;
+    amountPerPacket: bigint;
+}, {
+    token: `0x${string}`;
+    amountPerPacket: bigint;
+}>;
+export declare const FractionSchema: z.ZodObject<{
+    token: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    amount: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    amount: bigint;
+    token?: `0x${string}` | undefined;
+}, {
+    symbol: string;
+    name: string;
+    amount: bigint;
+    token?: `0x${string}` | undefined;
+}>;
+export declare const BurnForDiscountSchema: z.ZodObject<{
+    burnableTokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountToBurn: z.ZodBigInt;
+    percentDiscount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    burnableTokenAddress: `0x${string}`;
+    amountToBurn: bigint;
+    percentDiscount: number;
+}, {
+    burnableTokenAddress: `0x${string}`;
+    amountToBurn: bigint;
+    percentDiscount: number;
+}>;
+export declare const VestingSchema: z.ZodObject<{
+    cliff: z.ZodDate;
+    totalVestingPeriod: z.ZodNumber;
+    portionPeriod: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    cliff: Date;
+    totalVestingPeriod: number;
+    portionPeriod: number;
+}, {
+    cliff: Date;
+    totalVestingPeriod: number;
+    portionPeriod: number;
+}>;
+export declare const CreateFractionsRequestSchema: z.ZodObject<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    fractions: z.ZodObject<{
+        token: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    }, {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    }>;
+    timeBoundary: z.ZodObject<{
+        start: z.ZodDate;
+        end: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        start: Date;
+        end: Date;
+    }, {
+        start: Date;
+        end: Date;
+    }>;
+    cap: z.ZodObject<{
+        soft: z.ZodBigInt;
+        hard: z.ZodBigInt;
+        softPerAccount: z.ZodOptional<z.ZodBigInt>;
+        hardPerAccount: z.ZodOptional<z.ZodBigInt>;
+    }, "strip", z.ZodTypeAny, {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    }, {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    }>;
+    wrapped: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"ERC20">;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        values: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    }, {
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ERC721">;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ERC1155">;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+        values: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }>]>, "atleastone">;
+    funding: z.ZodArray<z.ZodObject<{
+        token: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        amountPerPacket: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        token: `0x${string}`;
+        amountPerPacket: bigint;
+    }, {
+        token: `0x${string}`;
+        amountPerPacket: bigint;
+    }>, "atleastone">;
+    discounts: z.ZodOptional<z.ZodObject<{
+        burnableTokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        amountToBurn: z.ZodBigInt;
+        percentDiscount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    }, {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    }>>;
+    vesting: z.ZodOptional<z.ZodObject<{
+        cliff: z.ZodDate;
+        totalVestingPeriod: z.ZodNumber;
+        portionPeriod: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        cliff: Date;
+        totalVestingPeriod: number;
+        portionPeriod: number;
+    }, {
+        cliff: Date;
+        totalVestingPeriod: number;
+        portionPeriod: number;
+    }>>;
+    refundAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountOfPacketsPerFraction: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    fractions: {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    };
+    cap: {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    };
+    market: `0x${string}`;
+    timeBoundary: {
+        start: Date;
+        end: Date;
+    };
+    wrapped: [{
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, ...({
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    })[]];
+    funding: [{
+        token: `0x${string}`;
+        amountPerPacket: bigint;
+    }, ...{
+        token: `0x${string}`;
+        amountPerPacket: bigint;
+    }[]];
+    refundAddress: `0x${string}`;
+    amountOfPacketsPerFraction: bigint;
+    discounts?: {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    } | undefined;
+    vesting?: {
+        cliff: Date;
+        totalVestingPeriod: number;
+        portionPeriod: number;
+    } | undefined;
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    fractions: {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    };
+    cap: {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    };
+    market: `0x${string}`;
+    timeBoundary: {
+        start: Date;
+        end: Date;
+    };
+    wrapped: [{
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, ...({
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    })[]];
+    funding: [{
+        token: `0x${string}`;
+        amountPerPacket: bigint;
+    }, ...{
+        token: `0x${string}`;
+        amountPerPacket: bigint;
+    }[]];
+    refundAddress: `0x${string}`;
+    amountOfPacketsPerFraction: bigint;
+    discounts?: {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    } | undefined;
+    vesting?: {
+        cliff: Date;
+        totalVestingPeriod: number;
+        portionPeriod: number;
+    } | undefined;
+}>;
+//# sourceMappingURL=createFractions.schema.d.ts.map

package/dist/src/fractions/createFractions/v0/createFractions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFractions.schema.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/createFractions/v0/createFractions.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAK7B,CAAC;AAGH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAqE,CAAC;AAGzG,eAAO,MAAM,aAAa;;;;;;;;;EAGxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAKzB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvC,CAAC"}

package/dist/src/fractions/createFractions/v0/createFractions.schema.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { AddressSchema, TmiChainIdSchema } from "../../../common/index.js";
+import { PercentageSchema } from "../../../common/models/index.js";
+// TimeBoundarySchema: Represents a time range with start and end dates
+export const TimeBoundarySchema = z.object({
+    start: z.coerce.date(),
+    end: z.coerce.date(),
+});
+// CapitalizationSchema: Represents the capitalization details of a market
+export const CapitalizationSchema = z.object({
+    soft: z.coerce.bigint().positive(),
+    hard: z.coerce.bigint().positive(),
+    softPerAccount: z.coerce.bigint().positive().optional(),
+    hardPerAccount: z.coerce.bigint().positive().optional(),
+});
+export const ERC20TokenSchema = z.object({
+    type: z.literal("ERC20"),
+    address: AddressSchema,
+    values: z.coerce.bigint().array().nonempty(),
+});
+export const ERC721TokenSchema = z.object({
+    type: z.literal("ERC721"),
+    address: AddressSchema,
+    tokenIds: z.coerce.bigint().array().nonempty(),
+});
+export const ERC1155TokenSchema = z.object({
+    type: z.literal("ERC1155"),
+    address: AddressSchema,
+    tokenIds: z.coerce.bigint().array().nonempty(),
+    values: z.coerce.bigint().array().nonempty(),
+});
+// Union schema to represent any of the three token types
+export const WrappedTokenTypeSchema = z.union([ERC20TokenSchema, ERC721TokenSchema, ERC1155TokenSchema]);
+// FundingSchema: Represents funding details for a market
+export const FundingSchema = z.object({
+    token: AddressSchema,
+    amountPerPacket: z.coerce.bigint().positive(),
+});
+export const FractionSchema = z.object({
+    token: AddressSchema.optional().describe("DO NOT USE. This field will be removed"),
+    symbol: z.string(),
+    name: z.string(),
+    amount: z.coerce.bigint().positive(),
+});
+export const BurnForDiscountSchema = z.object({
+    burnableTokenAddress: AddressSchema,
+    amountToBurn: z.coerce.bigint().positive("Amount to burn must be positive"),
+    percentDiscount: PercentageSchema,
+});
+export const VestingSchema = z.object({
+    cliff: z.coerce.date(),
+    totalVestingPeriod: z.number().positive(),
+    portionPeriod: z.number().positive(),
+});
+export const CreateFractionsRequestSchema = z.object({
+    chainId: TmiChainIdSchema,
+    market: AddressSchema,
+    fractions: FractionSchema,
+    timeBoundary: TimeBoundarySchema,
+    cap: CapitalizationSchema,
+    wrapped: z.array(WrappedTokenTypeSchema).nonempty(),
+    funding: z.array(FundingSchema).nonempty(),
+    discounts: BurnForDiscountSchema.optional(),
+    vesting: VestingSchema.optional(),
+    refundAddress: AddressSchema,
+    amountOfPacketsPerFraction: z.coerce.bigint().positive(),
+});

package/dist/src/fractions/createFractions/v0/parseFractionsCreatedEvent.d.ts

@@ -0,0 +1,51 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createGetFractionsCreatedEventRoute<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    campaignId: string;
+    creator: `0x${string}`;
+    nftId: string;
+    fractionsCreated: string;
+    fractionsAddress: `0x${string}`;
+    vaultAddress: `0x${string}` | undefined;
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    campaignId: string;
+    creator: `0x${string}`;
+    nftId: string;
+    fractionsCreated: string;
+    fractionsAddress: `0x${string}`;
+    vaultAddress: `0x${string}` | undefined;
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    campaignId: string;
+    creator: `0x${string}`;
+    nftId: string;
+    fractionsCreated: string;
+    fractionsAddress: `0x${string}`;
+    vaultAddress: `0x${string}` | undefined;
+}, 200, "json">>>];
+//# sourceMappingURL=parseFractionsCreatedEvent.d.ts.map

package/dist/src/fractions/createFractions/v0/parseFractionsCreatedEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFractionsCreatedEvent.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/createFractions/v0/parseFractionsCreatedEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAYvC,wBAAgB,mCAAmC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAiDrF"}

package/dist/src/fractions/createFractions/v0/parseFractionsCreatedEvent.js

@@ -0,0 +1,59 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { waitForTransactionReceipt } from "viem/actions";
+import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { HttpError } from "../../../common/http-error.js";
+import { z } from "../../../common/zod.js";
+import { CampaignIdSchema } from "../../sales/searchSaleEvents/v0/searchSaleEvents.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { parseFractionsCreatedEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export function createGetFractionsCreatedEventRoute(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get FractionsCreated Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`createFractions\` action`,
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            creator: AddressSchema,
+                            nftId: Int256Positive,
+                            campaignId: CampaignIdSchema,
+                            fractionsCreated: Int256Positive,
+                            fractionsAddress: AddressSchema,
+                            vaultAddress: AddressSchema,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+            hash: params.hash,
+        });
+        const result = parseFractionsCreatedEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParseFractionsCreatedEvent();
+        }
+        return c.json({
+            campaignId: result.campaignId.toString(),
+            creator: result.creator,
+            nftId: result.wrapperNftId.toString(),
+            fractionsCreated: result.fractionsCreated.toString(),
+            fractionsAddress: result.fractionsAddress,
+            vaultAddress: result.vaultAddress,
+        }, 200);
+    });
+}
+class UnableParseFractionsCreatedEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse FractionsCreated transaction. Make sure you're passing transaction that is generated by \`createFractions\` action`,
+            name: "UnableParseFractionsCreatedEvent",
+        });
+    }
+}