@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/fractions/nftfractions/v0/createNftFractions.routes.d.ts

@@ -0,0 +1,192 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+/**
+ * Creates handlers for the create NFT fractions endpoint
+ */
+export declare function createNftFractionsTransactionV0<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            nft: {
+                contractAddress: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            };
+            vesting?: {
+                totalVestingPeriod: number;
+                portionPeriod: number;
+                cliff: Date;
+            } | undefined;
+        };
+    };
+    out: {
+        json: {
+            chainId: 1 | 31337 | 11155111 | 72080;
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            nft: {
+                contractAddress: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            };
+            vesting?: {
+                totalVestingPeriod: number;
+                portionPeriod: number;
+                cliff: Date;
+            } | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            nft: {
+                contractAddress: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            };
+            vesting?: {
+                totalVestingPeriod: number;
+                portionPeriod: number;
+                cliff: Date;
+            } | undefined;
+        };
+    };
+    out: {
+        json: {
+            chainId: 1 | 31337 | 11155111 | 72080;
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            nft: {
+                contractAddress: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            };
+            vesting?: {
+                totalVestingPeriod: number;
+                portionPeriod: number;
+                cliff: Date;
+            } | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=createNftFractions.routes.d.ts.map

package/dist/fractions/nftfractions/v0/createNftFractions.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.routes.d.ts","sourceRoot":"","sources":["../../../../src/fractions/nftfractions/v0/createNftFractions.routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuBvC;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA8CjF"}

package/dist/fractions/nftfractions/v0/createNftFractions.routes.js

@@ -0,0 +1,58 @@
+import { describeRoute } from "hono-openapi";
+import { CreateNftFractionsRequestSchema } from "./createNftFractions.schema.js";
+import { resolver, validator } from "hono-openapi/zod";
+import { buildCreateNftFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+const route = describeRoute({
+    summary: "Create NFT fractions",
+    description: "Returns transaction data for wrapping ERC-721 tokens (NFTs) and creating ERC-20 compatible fractions. " +
+        "The NFT owner must first approve the market contract to transfer their NFTs.",
+    tags: ["NFT Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for creating NFT fractions",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+/**
+ * Creates handlers for the create NFT fractions endpoint
+ */
+export function createNftFractionsTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", CreateNftFractionsRequestSchema), async (c) => {
+        const { chainId, market, nft, fractions, timeBoundary, cap, funding, amountOfPacketsPerFraction, vesting, refundAddress, } = c.req.valid("json");
+        const tx = buildCreateNftFractionsTx({
+            chainId: chainId,
+            market: market,
+            nft: {
+                contractAddress: nft.contractAddress,
+                tokenIds: nft.tokenIds,
+            },
+            fractions: {
+                name: fractions.name,
+                symbol: fractions.symbol,
+                amount: fractions.amount,
+            },
+            timeBoundary: {
+                start: new Date(timeBoundary.start),
+                end: new Date(timeBoundary.end),
+            },
+            cap: cap,
+            funding: funding,
+            amountOfPacketsPerFraction: amountOfPacketsPerFraction,
+            vesting: vesting
+                ? {
+                    cliff: new Date(vesting.cliff),
+                    totalVestingPeriod: vesting.totalVestingPeriod,
+                    portionPeriod: vesting.portionPeriod,
+                }
+                : undefined,
+            refundAddress: refundAddress,
+        });
+        return c.json(toTransaction(tx));
+    });
+}

package/dist/fractions/nftfractions/v0/createNftFractions.schema.d.ts

@@ -0,0 +1,245 @@
+import { z } from "zod";
+/**
+ * Time boundary schema for sale period
+ */
+export declare const TimeBoundarySchema: z.ZodObject<{
+    start: z.ZodDate;
+    end: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    start: Date;
+    end: Date;
+}, {
+    start: Date;
+    end: Date;
+}>;
+/**
+ * Capitalization schema for sale limits
+ */
+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;
+}>;
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export declare const NftDetailsSchema: z.ZodObject<{
+    contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+}, "strip", z.ZodTypeAny, {
+    contractAddress: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}, {
+    contractAddress: `0x${string}`;
+    tokenIds: [bigint, ...bigint[]];
+}>;
+/**
+ * Fraction configuration schema
+ */
+export declare const FractionSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    amount: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    amount: bigint;
+}, {
+    symbol: string;
+    name: string;
+    amount: bigint;
+}>;
+/**
+ * Funding configuration schema for payment tokens
+ */
+export declare const FundingSchema: z.ZodObject<{
+    token: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountPerPacket: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    amountPerPacket: bigint;
+    token: `0x${string}`;
+}, {
+    amountPerPacket: bigint;
+    token: `0x${string}`;
+}>;
+/**
+ * Vesting configuration schema
+ */
+export declare const VestingSchema: z.ZodObject<{
+    cliff: z.ZodDate;
+    totalVestingPeriod: z.ZodNumber;
+    portionPeriod: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    totalVestingPeriod: number;
+    portionPeriod: number;
+    cliff: Date;
+}, {
+    totalVestingPeriod: number;
+    portionPeriod: number;
+    cliff: Date;
+}>;
+/**
+ * Request schema for creating NFT fractions
+ */
+export declare const CreateNftFractionsRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodEffects<z.ZodType<1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080", z.ZodTypeDef, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, 1 | 31337 | 11155111 | 72080, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, z.ZodType<1 | 31337 | 11155111 | 72080, z.ZodTypeDef, 1 | 31337 | 11155111 | 72080>>;
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    nft: z.ZodObject<{
+        contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        contractAddress: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, {
+        contractAddress: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }>;
+    fractions: z.ZodObject<{
+        name: z.ZodString;
+        symbol: z.ZodString;
+        amount: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        amount: bigint;
+    }, {
+        symbol: string;
+        name: string;
+        amount: bigint;
+    }>;
+    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;
+    }>;
+    funding: z.ZodArray<z.ZodObject<{
+        token: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        amountPerPacket: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }, {
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }>, "atleastone">;
+    amountOfPacketsPerFraction: z.ZodBigInt;
+    vesting: z.ZodOptional<z.ZodObject<{
+        cliff: z.ZodDate;
+        totalVestingPeriod: z.ZodNumber;
+        portionPeriod: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        totalVestingPeriod: number;
+        portionPeriod: number;
+        cliff: Date;
+    }, {
+        totalVestingPeriod: number;
+        portionPeriod: number;
+        cliff: Date;
+    }>>;
+    refundAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    chainId: 1 | 31337 | 11155111 | 72080;
+    fractions: {
+        symbol: string;
+        name: string;
+        amount: bigint;
+    };
+    cap: {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    };
+    market: `0x${string}`;
+    timeBoundary: {
+        start: Date;
+        end: Date;
+    };
+    funding: [{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }, ...{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }[]];
+    refundAddress: `0x${string}`;
+    amountOfPacketsPerFraction: bigint;
+    nft: {
+        contractAddress: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    };
+    vesting?: {
+        totalVestingPeriod: number;
+        portionPeriod: number;
+        cliff: Date;
+    } | undefined;
+}, {
+    chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
+    fractions: {
+        symbol: string;
+        name: string;
+        amount: bigint;
+    };
+    cap: {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    };
+    market: `0x${string}`;
+    timeBoundary: {
+        start: Date;
+        end: Date;
+    };
+    funding: [{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }, ...{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }[]];
+    refundAddress: `0x${string}`;
+    amountOfPacketsPerFraction: bigint;
+    nft: {
+        contractAddress: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    };
+    vesting?: {
+        totalVestingPeriod: number;
+        portionPeriod: number;
+        cliff: Date;
+    } | undefined;
+}>;
+//# sourceMappingURL=createNftFractions.schema.d.ts.map

package/dist/fractions/nftfractions/v0/createNftFractions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.schema.d.ts","sourceRoot":"","sources":["../../../../src/fractions/nftfractions/v0/createNftFractions.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;EAGxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaU,CAAC"}

package/dist/fractions/nftfractions/v0/createNftFractions.schema.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { AddressSchema, FractionsChainId } from "../../../common/index.js";
+/**
+ * Time boundary schema for sale period
+ */
+export const TimeBoundarySchema = z.object({
+    start: z.coerce.date().describe("Sale start date"),
+    end: z.coerce.date().describe("Sale end date"),
+});
+/**
+ * Capitalization schema for sale limits
+ */
+export const CapitalizationSchema = z.object({
+    soft: z.coerce.bigint().positive().describe("Soft cap - minimum funding target"),
+    hard: z.coerce.bigint().positive().describe("Hard cap - maximum funding limit"),
+    softPerAccount: z.coerce.bigint().positive().optional().describe("Optional soft cap per account"),
+    hardPerAccount: z.coerce.bigint().positive().optional().describe("Optional hard cap per account"),
+});
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export const NftDetailsSchema = z.object({
+    contractAddress: AddressSchema.describe("ERC-721 contract address"),
+    tokenIds: z.array(z.coerce.bigint().nonnegative()).nonempty().describe("Token IDs to wrap"),
+});
+/**
+ * Fraction configuration schema
+ */
+export const FractionSchema = z.object({
+    name: z.string().min(1).describe("Fraction token name"),
+    symbol: z.string().min(1).max(11).describe("Fraction token symbol"),
+    amount: z.coerce.bigint().positive().describe("Total supply of fractions to mint"),
+});
+/**
+ * Funding configuration schema for payment tokens
+ */
+export const FundingSchema = z.object({
+    token: AddressSchema.describe("Payment token address (e.g., USDC)"),
+    amountPerPacket: z.coerce.bigint().positive().describe("Amount of payment token per packet"),
+});
+/**
+ * Vesting configuration schema
+ */
+export const VestingSchema = z.object({
+    cliff: z.coerce.date().describe("Cliff date after which vesting begins"),
+    totalVestingPeriod: z.number().positive().describe("Total vesting period in seconds"),
+    portionPeriod: z.number().positive().describe("Period between vesting portions in seconds"),
+});
+/**
+ * Request schema for creating NFT fractions
+ */
+export const CreateNftFractionsRequestSchema = z
+    .object({
+    chainId: FractionsChainId.describe("Chain ID where the market is deployed"),
+    market: AddressSchema.describe("Address of the NFT Fractions market"),
+    nft: NftDetailsSchema.describe("NFT details to wrap"),
+    fractions: FractionSchema.describe("Fraction token configuration"),
+    timeBoundary: TimeBoundarySchema.describe("Purchase time window"),
+    cap: CapitalizationSchema.describe("Capitalization limits"),
+    funding: z.array(FundingSchema).nonempty().describe("Payment token configuration"),
+    amountOfPacketsPerFraction: z.coerce.bigint().positive().describe("Number of funding packets per fraction"),
+    vesting: VestingSchema.optional().describe("Optional vesting configuration"),
+    refundAddress: AddressSchema.describe("Address to receive refunds"),
+})
+    .openapi({ ref: "CreateNftFractionsRequestSchema" });

package/dist/fractions/nftfractions/v0/deployNftFractionsMarket.routes.d.ts

@@ -0,0 +1,96 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+/**
+ * Creates handlers for deploying an NFT Fractions market
+ */
+export declare function createDeployNftFractionsMarketTransactionV0<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            chainId: 31337 | 11155111 | "31337" | "11155111" | 72080 | "72080";
+            adminAddress: `0x${string}`;
+            acceptedFundingTokens: `0x${string}`[];
+            ownerAddress?: `0x${string}` | undefined;
+            cap?: {
+                maxHardCap: bigint;
+            } | undefined;
+            compilotSignerAddress?: `0x${string}` | undefined;
+            fee?: {
+                percent: number;
+            } | undefined;
+        };
+    };
+    out: {
+        json: {
+            chainId: 31337 | 11155111 | 72080;
+            adminAddress: `0x${string}`;
+            acceptedFundingTokens: `0x${string}`[];
+            ownerAddress?: `0x${string}` | undefined;
+            cap?: {
+                maxHardCap: bigint;
+            } | undefined;
+            compilotSignerAddress?: `0x${string}` | undefined;
+            fee?: {
+                percent: number;
+            } | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            chainId: 31337 | 11155111 | "31337" | "11155111" | 72080 | "72080";
+            adminAddress: `0x${string}`;
+            acceptedFundingTokens: `0x${string}`[];
+            ownerAddress?: `0x${string}` | undefined;
+            cap?: {
+                maxHardCap: bigint;
+            } | undefined;
+            compilotSignerAddress?: `0x${string}` | undefined;
+            fee?: {
+                percent: number;
+            } | undefined;
+        };
+    };
+    out: {
+        json: {
+            chainId: 31337 | 11155111 | 72080;
+            adminAddress: `0x${string}`;
+            acceptedFundingTokens: `0x${string}`[];
+            ownerAddress?: `0x${string}` | undefined;
+            cap?: {
+                maxHardCap: bigint;
+            } | undefined;
+            compilotSignerAddress?: `0x${string}` | undefined;
+            fee?: {
+                percent: number;
+            } | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=deployNftFractionsMarket.routes.d.ts.map

package/dist/fractions/nftfractions/v0/deployNftFractionsMarket.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarket.routes.d.ts","sourceRoot":"","sources":["../../../../src/fractions/nftfractions/v0/deployNftFractionsMarket.routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAyBvC;;GAEG;AACH,wBAAgB,2CAA2C,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAmB7F"}