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

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

@@ -1,88 +0,0 @@
-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>;
-/**
- * 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 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>[]]>>;
-    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    wrapped: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodLiteral<"ERC20">;
-        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        values: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"ERC721">;
-        address: 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>, z.ZodObject<{
-        type: z.ZodLiteral<"ERC1155">;
-        address: 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">>>>;
-        values: 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

@@ -1 +0,0 @@
-{"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;AAMxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,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

@@ -1,61 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, FractionsChainId } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-import { ISODate } from "../../../common/models/base/date.js";
-import { WrappedTokenTypeSchema } from "../../../fractions/sales/createFractions.schema.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"),
-});
-/**
- * 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"),
-    wrapped: z.array(WrappedTokenTypeSchema).nonempty().describe("Wrapped asset details to include in the sale"),
-    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

@@ -1,112 +0,0 @@
-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: {
-                    market: string;
-                    campaignId: string;
-                    chainId: unknown;
-                    amountToBuy: string;
-                    applyDiscount: boolean;
-                };
-            };
-            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;
-        };
-    };
-}, "/purchase"> | import("hono/types").MergeSchemaPath<{
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    chainId: unknown;
-                    market: string;
-                    wrapped: ({
-                        type: "ERC20";
-                        address: string;
-                        values: string[];
-                    } | {
-                        type: "ERC721";
-                        address: string;
-                        tokenIds: string[];
-                    } | {
-                        type: "ERC1155";
-                        address: string;
-                        tokenIds: string[];
-                        values: 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"> | import("hono/types").MergeSchemaPath<{
-    "/": {
-        $get: {
-            input: {
-                query: {
-                    chainId: string | string[];
-                    hash: string | string[];
-                };
-            };
-            output: {
-                campaignId: string;
-                creator: `0x${string}`;
-                nftId: string;
-                fractionsCreated: string;
-                fractionsAddress: `0x${string}`;
-                vaultAddress: `0x${string}` | undefined;
-            };
-            outputFormat: "json";
-            status: 200;
-        };
-    };
-}, "/getFractionsCreatedEvent">, "/", "/">>;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,11 +0,0 @@
-import { createController } from "../../../common/controller.js";
-import { PurchaseV0 } from "../../../fractions/sales/purchase.route.js";
-import { CreateNftFractionsV0 } from "./createNftFractions.routes.js";
-import { ParseNextFractionsCreatedEventV0 } from "./parseFractionsCreatedEvent.js";
-export const SalesController = createController({
-    build: (factory) => factory
-        .createApp()
-        .route("/nftFractions", CreateNftFractionsV0.build(factory))
-        .route("/getFractionsCreatedEvent", ParseNextFractionsCreatedEventV0.build(factory))
-        .route("/purchase", PurchaseV0.build(factory)),
-});

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

@@ -1,23 +0,0 @@
-export declare const ParseNextFractionsCreatedEventV0: 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: {
-                campaignId: string;
-                creator: `0x${string}`;
-                nftId: string;
-                fractionsCreated: string;
-                fractionsAddress: `0x${string}`;
-                vaultAddress: `0x${string}` | undefined;
-            };
-            outputFormat: "json";
-            status: 200;
-        };
-    };
-}, "/", "/">>;
-//# sourceMappingURL=parseFractionsCreatedEvent.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parseFractionsCreatedEvent.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/parseFractionsCreatedEvent.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;aAoD3C,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/approveCampaign.routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approveCampaign.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/approveCampaign.routes.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;aAO5B,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/createCampaign.routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createCampaign.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/createCampaign.routes.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA4CnD,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/createCampaign.schema.d.ts

@@ -1,43 +0,0 @@
-import { z } from "zod";
-/**
- * Issuer-provided fee schema for a single fee type.
- */
-export declare const IssuerFeeSchema: z.ZodObject<{
-    collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    proportion: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-}, z.core.$strip>;
-/**
- * Request schema for creating a Vesting & Redemption Dynamic campaign.
- */
-export declare const CreateVestingRedemptionDynamicCampaignRequestSchema: z.ZodObject<{
-    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 84532 | 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}`>>;
-        tokenId: 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;
-    }, 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}`>>;
-    funding: 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>;
-    startDate: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
-    softCapPerPurchase: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    hardCapPerAccount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    fundsReceiver: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    priceSetter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    fundsProvider: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    issuerEntryFee: z.ZodOptional<z.ZodObject<{
-        collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        proportion: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    }, z.core.$strip>>;
-    issuerExitFee: z.ZodOptional<z.ZodObject<{
-        collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        proportion: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-//# sourceMappingURL=createCampaign.schema.d.ts.map

package/dist/next/fractions/vestingRedemptionDynamic/createCampaign.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createCampaign.schema.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/createCampaign.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,eAAe;;;iBAM1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DC,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/createCampaign.schema.js

@@ -1,48 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, NextFractionsChainId } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-import { ISODate } from "../../../common/models/base/date.js";
-/**
- * Issuer-provided fee schema for a single fee type.
- */
-export const IssuerFeeSchema = z.object({
-    collectorAddress: AddressSchema.describe("Address that collects the fee"),
-    proportion: Int256BigInt(z.bigint().nonnegative()).describe("Fee proportion in 10^6 fixed-point (e.g. 40000 = 4%, 10000 = 1%). " +
-        "The total fee applied = platform-wide fee + this issuer fee."),
-});
-/**
- * Request schema for creating a Vesting & Redemption Dynamic campaign.
- */
-export const CreateVestingRedemptionDynamicCampaignRequestSchema = z
-    .object({
-    chainId: NextFractionsChainId.describe("Chain ID where the market is deployed"),
-    market: AddressSchema.describe("Address of the deployed Vesting & Redemption Dynamic market"),
-    nft: z
-        .object({
-        contractAddress: AddressSchema.describe("ERC-721 contract address"),
-        tokenId: Int256BigInt(z.bigint().nonnegative()).describe("Token ID of the NFT to wrap"),
-    })
-        .describe("ERC-721 NFT to wrap as the underlying collateral"),
-    fractions: z
-        .object({
-        name: z.string().min(1).describe("ERC-20 fraction token name"),
-        symbol: z.string().min(1).max(11).describe("ERC-20 fraction token symbol"),
-    })
-        .describe("ERC-20 fraction token metadata"),
-    refundAddress: AddressSchema.describe("Address that receives refunds if the campaign is incorrectly set up"),
-    funding: z
-        .object({
-        token: AddressSchema.describe("ERC-20 payment token address (must be an accepted funding token of the market)"),
-        amountPerPacket: Int256BigInt(z.bigint().positive()).describe("Amount of payment token per funding packet (in raw token units, e.g. 1e6 for 1 USDC with 6 decimals)"),
-    })
-        .describe("Payment token configuration"),
-    startDate: ISODate().describe("Campaign start date in ISO 8601 format. No purchases can be made before this time."),
-    softCapPerPurchase: Int256BigInt(z.bigint().positive()).describe("Minimum number of funding packets per single purchase call"),
-    hardCapPerAccount: Int256BigInt(z.bigint().positive()).describe("Maximum total funding packets an investor may provide across all purchases"),
-    fundsReceiver: AddressSchema.describe("Address that receives the funds provided by investors (the issuer or fund manager wallet)"),
-    priceSetter: AddressSchema.describe("Address authorised to call setPrice and advance the epoch"),
-    fundsProvider: AddressSchema.describe("Address that must supply withdrawal funds when the price setter advances the epoch. Typically the same as priceSetter."),
-    issuerEntryFee: IssuerFeeSchema.optional().describe("Issuer-provided entry fee applied on top of the platform-wide purchase fee"),
-    issuerExitFee: IssuerFeeSchema.optional().describe("Issuer-provided exit fee applied on top of the platform-wide withdrawal fee"),
-})
-    .openapi("CreateVestingRedemptionDynamicCampaignRequestSchema");

package/dist/next/fractions/vestingRedemptionDynamic/deployMarket.routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployMarket.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/deployMarket.routes.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2BjD,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/deployMarket.schema.d.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-/**
- * Request schema for deploying a Vesting & Redemption Dynamic market.
- */
-export declare const DeployVestingRedemptionDynamicMarketRequestSchema: z.ZodObject<{
-    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 84532 | 72080>[]]>>;
-    adminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    ownerAddress: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
-    acceptedFundingTokens: z.ZodArray<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
-    platformEntryFee: z.ZodOptional<z.ZodObject<{
-        collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        basisPoints: z.ZodNumber;
-    }, z.core.$strip>>;
-    platformExitFee: z.ZodOptional<z.ZodObject<{
-        collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        basisPoints: z.ZodNumber;
-    }, z.core.$strip>>;
-    receiptNft: z.ZodOptional<z.ZodObject<{
-        baseName: z.ZodString;
-        baseSymbol: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-//# sourceMappingURL=deployMarket.schema.d.ts.map

package/dist/next/fractions/vestingRedemptionDynamic/deployMarket.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployMarket.schema.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/deployMarket.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;GAEG;AACH,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;iBAsBC,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/deployMarket.schema.js

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, NextFractionsChainId } from "../../../common/index.js";
-/**
- * Platform-wide fee configuration for a single fee type (entry or exit).
- */
-const PlatformFeeSchema = z.object({
-    collectorAddress: AddressSchema.describe("Address that receives the fee"),
-    basisPoints: z.number().int().min(0).max(10000).describe("Fee in basis points (1 = 0.01%, 10000 = 100%)"),
-});
-/**
- * Request schema for deploying a Vesting & Redemption Dynamic market.
- */
-export const DeployVestingRedemptionDynamicMarketRequestSchema = z
-    .object({
-    chainId: NextFractionsChainId.describe("Chain ID where the market will be deployed"),
-    adminAddress: AddressSchema.describe("Address of the market administrator. Also used as the approval authority for campaigns."),
-    ownerAddress: AddressSchema.optional().describe("Diamond owner address. Defaults to adminAddress if not provided."),
-    acceptedFundingTokens: z.array(AddressSchema).nonempty().describe("ERC-20 token addresses accepted as payment."),
-    platformEntryFee: PlatformFeeSchema.optional().describe("Platform-wide entry fee applied to all purchase transactions."),
-    platformExitFee: PlatformFeeSchema.optional().describe("Platform-wide exit fee applied to all epoch price updates (withdrawals)."),
-    receiptNft: z
-        .object({
-        baseName: z.string().min(1).describe("Base name for receipt NFTs (used for purchase and withdrawal receipts)"),
-        baseSymbol: z.string().min(1).max(11).describe("Base symbol for receipt NFTs"),
-    })
-        .optional()
-        .describe("Custom receipt NFT metadata. Defaults to 'VRD Receipt' / 'VRD'."),
-})
-    .openapi("DeployVestingRedemptionDynamicMarketRequestSchema");

package/dist/next/fractions/vestingRedemptionDynamic/epochPurchase.routes.d.ts

@@ -1,51 +0,0 @@
-export declare const EpochPurchaseV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    market: string;
-                    campaignId: string;
-                    amountToProvide: 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;
-        };
-    };
-}, "/", "/">>;
-export declare const ExchangeNftForFractionsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    market: string;
-                    campaignId: string;
-                    nftId: 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=epochPurchase.routes.d.ts.map

package/dist/next/fractions/vestingRedemptionDynamic/epochPurchase.routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"epochPurchase.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/epochPurchase.routes.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAO1B,CAAC;AAkCH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;aAOpC,CAAC"}

package/dist/next/fractions/vestingRedemptionDynamic/epochPurchase.routes.js

@@ -1,74 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
-import { buildEpochPurchaseTx, buildExchangeNftForFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { createController } from "../../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-// ─────────────────────────────── Purchase (step 1) ───────────────────────────
-const EpochPurchaseRequestSchema = z
-    .object({
-    market: AddressSchema.describe("Address of the Vesting & Redemption Dynamic market"),
-    campaignId: Int256BigInt(z.bigint().nonnegative()).describe("Campaign ID"),
-    amountToProvide: Int256BigInt(z.bigint().positive()).describe("Number of funding packets to provide (must satisfy softCapPerPurchase ≤ value ≤ remaining hardCapPerAccount). " +
-        "The market transfers amountToProvide × amountPerPacket tokens from the caller."),
-})
-    .openapi("EpochPurchaseRequestSchema");
-const purchaseRoute = describeRoute({
-    summary: "Purchase step 1 — provide funds and receive receipt NFT",
-    description: "Returns transaction data for the first step of the two-click epoch purchase flow. " +
-        "The investor provides funding packets and receives a purchase receipt NFT. " +
-        "Prerequisites: investor must hold the INVESTOR role, and must have approved " +
-        "the market to spend their ERC-20 payment tokens.",
-    tags: ["Vesting & Redemption Dynamic"],
-    responses: {
-        200: {
-            description: "Returns transaction data for the epoch purchase",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export const EpochPurchaseV0 = createController({
-    build: (factory) => factory.createApp().post("/", purchaseRoute, validator("json", EpochPurchaseRequestSchema), async (c) => {
-        const { market, campaignId, amountToProvide } = c.req.valid("json");
-        const tx = buildEpochPurchaseTx({ market, campaignId, amountToProvide });
-        return c.json(toTransaction(tx));
-    }),
-});
-// ──────────────────────────── Exchange NFT for Fractions (step 2) ────────────
-const ExchangeNftForFractionsRequestSchema = z
-    .object({
-    market: AddressSchema.describe("Address of the Vesting & Redemption Dynamic market"),
-    campaignId: Int256BigInt(z.bigint().nonnegative()).describe("Campaign ID"),
-    nftId: Int256BigInt(z.bigint().nonnegative()).describe("ID of the purchase receipt NFT (emitted in the NftPurchased event from step 1)"),
-})
-    .openapi("ExchangeNftForFractionsRequestSchema");
-const exchangeRoute = describeRoute({
-    summary: "Purchase step 2 — burn receipt NFT and receive ERC-20 fractions",
-    description: "Returns transaction data for the second step of the two-click epoch purchase flow. " +
-        "The investor burns their purchase receipt NFT and receives ERC-20 fractions priced at epoch N+1, " +
-        "where N is the epoch in which the receipt was minted. " +
-        "This can only be called after the price setter has advanced the epoch at least once since the purchase.",
-    tags: ["Vesting & Redemption Dynamic"],
-    responses: {
-        200: {
-            description: "Returns transaction data for the NFT exchange",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export const ExchangeNftForFractionsV0 = createController({
-    build: (factory) => factory.createApp().post("/", exchangeRoute, validator("json", ExchangeNftForFractionsRequestSchema), async (c) => {
-        const { market, campaignId, nftId } = c.req.valid("json");
-        const tx = buildExchangeNftForFractionsTx({ market, campaignId, nftId });
-        return c.json(toTransaction(tx));
-    }),
-});