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

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

@@ -1,416 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,67 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}