@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

package/dist/next/fractions/platforms/index.d.ts

@@ -0,0 +1,36 @@
+export declare const PlatformsController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: string;
+                    acceptedFundingTokens: string[];
+                    ownerAddress?: string | undefined;
+                    compilotSignerAddress?: string | undefined;
+                    cap?: {
+                        maxHardCap: string;
+                    } | undefined;
+                    fee?: {
+                        percent: number;
+                        collectorAddress: string;
+                        feeAdmin: 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;
+        };
+    };
+}, "/deployNftFractions">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/next/fractions/platforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/platforms/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAE9B,CAAC"}

package/dist/next/fractions/platforms/index.js

@@ -0,0 +1,5 @@
+import { createController } from "../../../common/controller.js";
+import { DeployNftFractionsMarketV0 } from "./deployNftFractionsMarket.routes.js";
+export const PlatformsController = createController({
+    build: (factory) => factory.createApp().route("/deployNftFractions", DeployNftFractionsMarketV0.build(factory)),
+});

package/dist/next/fractions/sales/createNftFractions.routes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Controller for the create NFT fractions endpoint
+ */
+export declare const CreateNftFractionsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    nft: {
+                        contractAddress: string;
+                        tokenIds: string[];
+                    };
+                    fractions: {
+                        name: string;
+                        symbol: string;
+                        amount: string;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    amountOfPacketsPerFraction: string;
+                    refundAddress: string;
+                    vesting?: {
+                        cliff: string;
+                        totalVestingPeriod: number;
+                        portionPeriod: number;
+                    } | 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=createNftFractions.routes.d.ts.map

package/dist/next/fractions/sales/createNftFractions.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/createNftFractions.routes.ts"],"names":[],"mappings":"AAyBA;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+C/B,CAAC"}

package/dist/next/fractions/sales/createNftFractions.routes.js

@@ -0,0 +1,59 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildCreateNftFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+import { CreateNftFractionsRequestSchema } from "./createNftFractions.schema.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),
+                },
+            },
+        },
+    },
+});
+/**
+ * Controller for the create NFT fractions endpoint
+ */
+export const CreateNftFractionsV0 = createController({
+    build: (factory) => factory.createApp().post("/", 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/next/fractions/sales/createNftFractions.schema.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+/**
+ * Time boundary schema for sale period
+ */
+export declare const TimeBoundarySchema: z.ZodObject<{
+    start: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    end: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+}, z.core.$strip>;
+/**
+ * Capitalization schema for sale limits
+ */
+export declare const CapitalizationSchema: z.ZodObject<{
+    soft: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    hard: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    softPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    hardPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+}, z.core.$strip>;
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export declare const NftDetailsSchema: z.ZodObject<{
+    contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+}, z.core.$strip>;
+/**
+ * Fraction configuration schema
+ */
+export declare const FractionSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Funding configuration schema for payment tokens
+ */
+export declare const FundingSchema: z.ZodObject<{
+    token: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amountPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Vesting configuration schema
+ */
+export declare const VestingSchema: z.ZodObject<{
+    cliff: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    totalVestingPeriod: z.ZodNumber;
+    portionPeriod: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Request schema for creating NFT fractions
+ */
+export declare const CreateNftFractionsRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 72080>[]]>>;
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    nft: z.ZodObject<{
+        contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>;
+    fractions: z.ZodObject<{
+        name: z.ZodString;
+        symbol: z.ZodString;
+        amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>;
+    timeBoundary: z.ZodObject<{
+        start: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+        end: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    }, z.core.$strip>;
+    cap: z.ZodObject<{
+        soft: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        hard: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        softPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+        hardPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>;
+    funding: z.ZodArray<z.ZodObject<{
+        token: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amountPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>>;
+    amountOfPacketsPerFraction: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    vesting: z.ZodOptional<z.ZodObject<{
+        cliff: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+        totalVestingPeriod: z.ZodNumber;
+        portionPeriod: z.ZodNumber;
+    }, z.core.$strip>>;
+    refundAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+//# sourceMappingURL=createNftFractions.schema.d.ts.map

package/dist/next/fractions/sales/createNftFractions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.schema.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/createNftFractions.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;iBAIzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;iBAGxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;iBAIxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaC,CAAC"}

package/dist/next/fractions/sales/createNftFractions.schema.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { AddressSchema, FractionsChainId } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { ISODate } from "../../../common/models/date.js";
+/**
+ * Time boundary schema for sale period
+ */
+export const TimeBoundarySchema = z.object({
+    start: ISODate().describe("Sale start date"),
+    end: ISODate().describe("Sale end date"),
+});
+/**
+ * Capitalization schema for sale limits
+ */
+export const CapitalizationSchema = z.object({
+    soft: Int256BigInt(z.bigint().positive()).describe("Soft cap - minimum funding target"),
+    hard: Int256BigInt(z.bigint().positive()).describe("Hard cap - maximum funding limit"),
+    softPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional soft cap per account"),
+    hardPerAccount: Int256BigInt(z.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(Int256BigInt(z.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: Int256BigInt(z.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: Int256BigInt(z.bigint().positive()).describe("Amount of payment token per packet"),
+});
+/**
+ * Vesting configuration schema
+ */
+export const VestingSchema = z.object({
+    cliff: ISODate().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: Int256BigInt(z.bigint().positive()).describe("Number of funding packets per fraction"),
+    vesting: VestingSchema.optional().describe("Optional vesting configuration"),
+    refundAddress: AddressSchema.describe("Address to receive refunds"),
+})
+    .openapi("CreateNftFractionsRequestSchema");

package/dist/next/fractions/sales/index.d.ts

@@ -0,0 +1,55 @@
+export declare const SalesController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    nft: {
+                        contractAddress: string;
+                        tokenIds: string[];
+                    };
+                    fractions: {
+                        name: string;
+                        symbol: string;
+                        amount: string;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    amountOfPacketsPerFraction: string;
+                    refundAddress: string;
+                    vesting?: {
+                        cliff: string;
+                        totalVestingPeriod: number;
+                        portionPeriod: number;
+                    } | 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;
+        };
+    };
+}, "/nftFractions">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/next/fractions/sales/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAE1B,CAAC"}

package/dist/next/fractions/sales/index.js

@@ -0,0 +1,5 @@
+import { createController } from "../../../common/controller.js";
+import { CreateNftFractionsV0 } from "./createNftFractions.routes.js";
+export const SalesController = createController({
+    build: (factory) => factory.createApp().route("/nftFractions", CreateNftFractionsV0.build(factory)),
+});