@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/issuance/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAmBvC,eAAO,MAAM,YAAY;;gBAEX,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB/C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAStB,CAAC"}

package/dist/issuance/index.js

@@ -1,34 +1,13 @@
-import { createApiConfig } from "../common/app.js";
-import { approveErc20Token } from "./approve.js";
-import { burnErc20Token } from "./burn.js";
-import { createErc1967Proxy, createErc20Token, createTransparentUpgradeableProxy, createProxyAdmin, createErc721Token, } from "./deploy.js";
-import { mintErc20Token } from "./mint.js";
-import { transferErc20Token } from "./transfer.js";
-import { createGrantRole } from "./grantRole.js";
-import { createRenounceRole } from "./renounceRole.js";
-import { upgradeTransparentProxy } from "./upgrade.js";
-import { createGetErc20InitData } from "./getInitData.js";
-import { recoverErc20 } from "./recover.js";
-export const issuanceApis = {
-    name: "Issuance APIs",
-    createApp: (factory) => factory.createApp().route("/issuance", factory
+import { createApi } from "../common/controller.js";
+import { Erc20Controller } from "./erc20/index.js";
+import { Erc721Controller } from "./erc721/index.js";
+import { ProxyController } from "./proxy/index.js";
+export const IssuanceApi = createApi({
+    title: "Issuance API",
+    description: "APIs for issuing tokens",
+    build: (factory) => factory
         .createApp()
-        .get("/erc20", ...createErc20Token(factory))
-        .post("/erc20/mint", ...mintErc20Token(factory))
-        .post("/erc20/burn", ...burnErc20Token(factory))
-        .post("/erc20/approve", ...approveErc20Token(factory))
-        .post("/erc20/transfer", ...transferErc20Token(factory))
-        .post("/erc20/proxy", ...createErc1967Proxy(factory))
-        .post("/erc20/grantRole", ...createGrantRole(factory))
-        .post("/erc20/renounceRole", ...createRenounceRole(factory))
-        .post("/erc20/getInitData", ...createGetErc20InitData(factory))
-        .post("/erc20/recover", ...recoverErc20(factory))
-        .post("/erc721/deploy", ...createErc721Token(factory))
-        .get("/proxy/deployProxyAdmin", ...createProxyAdmin(factory))
-        .post("/proxy/deployTransparentProxy", ...createTransparentUpgradeableProxy(factory))
-        .post("/proxy/upgradeTransparentProxy", ...upgradeTransparentProxy(factory))),
-    config: createApiConfig({
-        title: "Issuance API",
-        description: "APIs for issuing tokens",
-    }),
-};
+        .route("/erc20", Erc20Controller.build(factory))
+        .route("/erc721", Erc721Controller.build(factory))
+        .route("/proxy", ProxyController.build(factory)),
+});

package/dist/issuance/mint.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 export const MintErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     amount: z.coerce.bigint().nonnegative(),

package/dist/issuance/proxy/deploy.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const DeployTransparentUpgradeableProxySchema: z.ZodObject<{
+    implementation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    proxyAdminOwner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    initData: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const CreateTransparentUpgradeableProxy: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    implementation: string;
+                    proxyAdminOwner: string;
+                    initData: string;
+                };
+            };
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+export declare const CreateProxyAdmin: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/issuance/proxy/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2BxB,eAAO,MAAM,uCAAuC;;;;iBASlD,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;QAa5C,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;QAQ3B,CAAC"}

package/dist/issuance/proxy/deploy.js

@@ -0,0 +1,68 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { proxyAdminAbi, proxyAdminBytecode } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
+import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-protocol-contracts/transparentProxy";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, DeployTransactionSchema, HexStringSchema } from "../../common/index.js";
+// Issue generic TUP contract
+const deployTransparentProxyRoute = describeRoute({
+    summary: "Deploy TransparentUpgradeableProxy",
+    description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
+            content: {
+                "application/json": {
+                    schema: resolver(DeployTransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const DeployTransparentUpgradeableProxySchema = z.object({
+    implementation: AddressSchema.openapi("The address of the implementation contract"),
+    proxyAdminOwner: AddressSchema.openapi("The address of the proxy admin who is eligible to upgrade implementation"),
+    initData: HexStringSchema.openapi(`Encoded function call hex data for underlying implementation contract initialization.
+
+    Can be combined with "encodeFunctionData" of viem.
+    NOTE: The underlying implementation contract must have initialization function.
+    `),
+});
+export const CreateTransparentUpgradeableProxy = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", deployTransparentProxyRoute, validator("json", DeployTransparentUpgradeableProxySchema), async (c) => {
+        const { implementation, proxyAdminOwner, initData } = c.req.valid("json");
+        return c.json({
+            bytecode: transparentUpgradeableProxyBytecode,
+            abi: transparentUpgradeableProxyAbi,
+            args: [implementation, proxyAdminOwner, initData],
+        });
+    }),
+});
+// Issue generic ProxyAdmin contract
+const deployProxyAdminRoute = describeRoute({
+    summary: "Deploy ProxyAdmin",
+    description: "Returns transaction data for deploying a ProxyAdmin contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a ProxyAdmin contract",
+            content: {
+                "application/json": {
+                    schema: resolver(DeployTransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateProxyAdmin = createController({
+    build: (factory) => factory.createApp().get("/", deployProxyAdminRoute, async (c) => {
+        return c.json({
+            bytecode: proxyAdminBytecode,
+            abi: proxyAdminAbi,
+        });
+    }),
+});

package/dist/issuance/proxy/index.d.ts

@@ -0,0 +1,59 @@
+export declare const ProxyController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployProxyAdmin"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    implementation: string;
+                    proxyAdminOwner: string;
+                    initData: string;
+                };
+            };
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployTransparentProxy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    proxyAdminAddress: string;
+                    proxyAddress: string;
+                    newImplementation: string;
+                    data?: 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;
+        };
+    };
+}, "/upgradeTransparentProxy">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/issuance/proxy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAO1B,CAAC"}

package/dist/issuance/proxy/index.js

@@ -0,0 +1,10 @@
+import { createController } from "../../common/controller.js";
+import { CreateProxyAdmin, CreateTransparentUpgradeableProxy } from "./deploy.js";
+import { UpgradeProxy } from "./upgrade.js";
+export const ProxyController = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/deployProxyAdmin", CreateProxyAdmin.build(factory))
+        .route("/deployTransparentProxy", CreateTransparentUpgradeableProxy.build(factory))
+        .route("/upgradeTransparentProxy", UpgradeProxy.build(factory)),
+});

package/dist/issuance/proxy/upgrade.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const UpgradeProxyRequestSchema: z.ZodObject<{
+    proxyAdminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    proxyAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    newImplementation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    data: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
+export declare const UpgradeProxy: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    proxyAdminAddress: string;
+                    proxyAddress: string;
+                    newImplementation: string;
+                    data?: 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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=upgrade.d.ts.map

package/dist/issuance/proxy/upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/upgrade.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,yBAAyB;;;;;iBAapC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;QAcvB,CAAC"}

package/dist/issuance/proxy/upgrade.js

@@ -0,0 +1,46 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { proxyAdminAbi } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+export const UpgradeProxyRequestSchema = z.object({
+    proxyAdminAddress: AddressSchema.openapi({
+        description: "The address of the ProxyAdmin contract that manages the proxy",
+    }),
+    proxyAddress: AddressSchema.openapi({
+        description: "The address of the transparent proxy contract to upgrade",
+    }),
+    newImplementation: AddressSchema.openapi({
+        description: "The address of the new implementation contract",
+    }),
+    data: HexStringSchema.optional().openapi({
+        description: "Initialization data",
+    }),
+});
+const upgradeRoute = describeRoute({
+    summary: "Upgrade Transparent Proxy Implementation",
+    description: "Returns transaction data for upgrading the implementation of a transparent proxy contract using ProxyAdmin",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for upgrading transparent proxy implementation via ProxyAdmin",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const UpgradeProxy = createController({
+    build: (factory) => factory.createApp().post("/", upgradeRoute, validator("json", UpgradeProxyRequestSchema), async (c) => {
+        const { proxyAdminAddress, proxyAddress, newImplementation, data } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: proxyAdminAddress,
+            abi: proxyAdminAbi,
+            functionName: "upgradeAndCall",
+            args: [proxyAddress, newImplementation, data || "0x"],
+        }));
+    }),
+});

package/dist/issuance/recover.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 import { toHex } from "viem";
 export const RecoverErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,

package/dist/issuance/renounceRole.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 import { convertRoleToHash, Erc20GatedRole } from "../common/roles/erc20-gated-roles.js";
 // Define the schema for the renounce role request
 export const RenounceRoleSchema = z.object({

package/dist/issuance/transfer.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 export const TransferErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema,

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

@@ -0,0 +1,275 @@
+export declare const NextFractionsApi: import("../../common/controller.js").IApi<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<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">, "/platforms"> | import("hono/types").MergeSchemaPath<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">, "/sales"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: string;
+                    minInterest: number;
+                    maxInterest: number;
+                    minDuration: string;
+                    maxDuration: string;
+                    minimumProportionOverObligation: string;
+                    ownerAddress?: string | undefined;
+                    discount?: {
+                        burnForDiscount: {
+                            burnableTokenAddress: 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;
+        };
+    };
+}, "/deploy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    fractions: {
+                        symbol: string;
+                        name: string;
+                        amount: string;
+                        token?: string | undefined;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
+                        tokenIds: string[];
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    refundAddress: string;
+                    amountOfPacketsPerFraction: string;
+                    buyback: {
+                        durationSeconds: number;
+                        interestPercentage: number;
+                        liquidationLimitPercentage: number;
+                        marginCallLimitPercentage: number;
+                    };
+                    discounts?: {
+                        burnableTokenAddress: string;
+                        amountToBurn: string;
+                        percentDiscount: 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;
+        };
+    };
+}, "/createSale"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    chainId: unknown;
+                    amountToBuy: 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;
+        };
+    };
+}, "/purchase"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    collateralPriceInFundingPackets: string;
+                    market: string;
+                    campaignId: 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;
+        };
+    };
+}, "/setCollateralPrice"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    buybackPacketsAmount: string;
+                    market: string;
+                    campaignId: 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;
+        };
+    };
+}, "/buyback">, "/lending">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/next/fractions/index.js

@@ -0,0 +1,13 @@
+import { createApi } from "../../common/controller.js";
+import { LendingController } from "./lending/index.js";
+import { PlatformsController } from "./platforms/index.js";
+import { SalesController } from "./sales/index.js";
+export const NextFractionsApi = createApi({
+    title: "Next Fractions API",
+    description: "NFT Fractions and Lending markets (next-gen SDK)",
+    build: (factory) => factory
+        .createApp()
+        .route("/platforms", PlatformsController.build(factory))
+        .route("/sales", SalesController.build(factory))
+        .route("/lending", LendingController.build(factory)),
+});