@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/fractions/platforms/deployNftFractionsMarket.routes.d.ts

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

package/dist/fractions/platforms/deployNftFractionsMarket.routes.d.ts.map

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

package/dist/fractions/platforms/deployNftFractionsMarket.routes.js

@@ -0,0 +1,52 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { zeroAddress } from "viem";
+import { getEnv, getEnvNumber } from "@evergonlabs/internal/node/getEnv";
+import { createNftFractionsPlatform } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../common/index.js";
+import { DeployNftFractionsMarketRequestSchema } from "./deployNftFractionsMarket.schema.js";
+const route = describeRoute({
+    summary: "Deploy an NFT Fractions market",
+    description: "Returns transaction data for deploying an NFT Fractions market with ComPilot gating. " +
+        "This market type supports wrapping ERC-721 tokens and fractionalizing them into ERC-20 compatible tokens.",
+    tags: ["NFT Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying an NFT Fractions market",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+/**
+ * Creates handlers for deploying an NFT Fractions market
+ */
+export function createDeployNftFractionsMarketTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", DeployNftFractionsMarketRequestSchema), async (c) => {
+        const { chainId, adminAddress, ownerAddress, compilotSignerAddress, cap, fee, acceptedFundingTokens } = c.req.valid("json");
+        const platformFee = getFeeConfig();
+        const tx = createNftFractionsPlatform({
+            chainId: chainId,
+            adminAddress: adminAddress,
+            ownerAddress: ownerAddress ?? adminAddress,
+            compilotSignerAddress: compilotSignerAddress ?? DEFAULT_COMPILOT_SIGNER,
+            fee: { ...platformFee, ...fee },
+            maxHardCap: cap ? cap.maxHardCap : null,
+            acceptedFundingTokens: acceptedFundingTokens,
+        });
+        return c.json(toTransaction(tx));
+    });
+}
+/**
+ * Gets the default fee configuration from environment variables
+ */
+function getFeeConfig() {
+    return {
+        percent: getEnvNumber("PLATFORM_FEE_SIZE_BP", 0),
+        collectorAddress: getEnv("PLATFORM_FEE_COLLECTOR_ADDRESS", zeroAddress),
+        feeAdmin: getEnv("PLATFORM_FEE_ADMIN", zeroAddress),
+    };
+}

package/dist/fractions/platforms/deployNftFractionsMarket.schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/**
+ * Cap configuration schema for market limits
+ */
+export declare const CapConfigSchema: z.ZodObject<{
+    maxHardCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Fee configuration schema for market fees
+ */
+export declare const FeeConfigSchema: z.ZodObject<{
+    percent: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Request schema for deploying an NFT Fractions market
+ */
+export declare const DeployNftFractionsMarketRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 72080>, z.ZodLiteral<11155111 | 31337 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 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}`>>>;
+    compilotSignerAddress: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    cap: z.ZodOptional<z.ZodObject<{
+        maxHardCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>>;
+    fee: z.ZodOptional<z.ZodObject<{
+        percent: z.ZodNumber;
+    }, z.core.$strip>>;
+    acceptedFundingTokens: z.ZodArray<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=deployNftFractionsMarket.schema.d.ts.map

package/dist/fractions/platforms/deployNftFractionsMarket.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarket.schema.d.ts","sourceRoot":"","sources":["../../../src/fractions/platforms/deployNftFractionsMarket.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,eAAO,MAAM,eAAe;;iBAE1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;iBAE1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;iBAcC,CAAC"}

package/dist/fractions/platforms/deployNftFractionsMarket.schema.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { AddressSchema, NextFractionsChainId, PercentageSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+/**
+ * Cap configuration schema for market limits
+ */
+export const CapConfigSchema = z.object({
+    maxHardCap: Int256BigInt(z.bigint().min(BigInt(1))).describe("Maximum hard cap for the market"),
+});
+/**
+ * Fee configuration schema for market fees
+ */
+export const FeeConfigSchema = z.object({
+    percent: PercentageSchema.describe("Fee percentage in basis points"),
+});
+/**
+ * Request schema for deploying an NFT Fractions market
+ */
+export const DeployNftFractionsMarketRequestSchema = z
+    .object({
+    chainId: NextFractionsChainId.describe("Chain ID where the market will be deployed"),
+    adminAddress: AddressSchema.describe("Address of the market administrator"),
+    ownerAddress: AddressSchema.optional().describe("Address of the market owner. Defaults to adminAddress if not provided"),
+    compilotSignerAddress: AddressSchema.optional().describe("ComPilot signer address. Uses platform default if not provided"),
+    cap: CapConfigSchema.optional().describe("Optional cap configuration"),
+    fee: FeeConfigSchema.optional().describe("Optional fee configuration"),
+    acceptedFundingTokens: z.array(AddressSchema).describe("Accepted funding token addresses"),
+})
+    .openapi("DeployNftFractionsMarketRequestSchema");

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

@@ -0,0 +1,196 @@
+export * from "./deployMarket.schema.js";
+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;
+                    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;
+                    adminAddress: 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;
+        };
+    };
+}, "/deployContinuousWithdraw"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: 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;
+        };
+    };
+}, "/deployContinuousWithdrawNid"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: 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;
+        };
+    };
+}, "/deployNid"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    market: 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;
+        };
+    };
+}, "/initCompilot"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    market: string;
+                    signerAddress?: 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;
+        };
+    };
+}, "/initNftFractionsCompilot">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/fractions/platforms/index.js

@@ -0,0 +1,15 @@
+import { createController } from "../../common/controller.js";
+import { DeployCompilotMarketV0, DeployContinuousWithdrawMarketV0, DeployContinuousWithdrawNidMarketV0, DeployMarketV0, } from "./deployMarket.routes.js";
+import { InitCompilotV0 } from "./initCompilot.routes.js";
+import { InitNidV0 } from "./initNid.route.js";
+export * from "./deployMarket.schema.js";
+export const PlatformsController = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/deploy", DeployMarketV0.build(factory))
+        .route("/deployContinuousWithdraw", DeployContinuousWithdrawMarketV0.build(factory))
+        .route("/deployContinuousWithdrawNid", DeployContinuousWithdrawNidMarketV0.build(factory))
+        .route("/deployNid", DeployCompilotMarketV0.build(factory))
+        .route("/initCompilot", InitNidV0.build(factory))
+        .route("/initNftFractionsCompilot", InitCompilotV0.build(factory)),
+});

package/dist/fractions/platforms/initCompilot.routes.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Request schema for initializing ComPilot signer
+ */
+export declare const InitNftFractionsCompilotRequestSchema: z.ZodObject<{
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    signerAddress: 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>;
+/**
+ * Controller for initializing ComPilot signer on NFT Fractions market
+ */
+export declare const InitCompilotV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    market: string;
+                    signerAddress?: 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=initCompilot.routes.d.ts.map

package/dist/fractions/platforms/initCompilot.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initCompilot.routes.d.ts","sourceRoot":"","sources":["../../../src/fractions/platforms/initCompilot.routes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;iBAGhD,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;QASzB,CAAC"}

package/dist/fractions/platforms/initCompilot.routes.js

@@ -0,0 +1,40 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { initCompilotSigner } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../common/index.js";
+const route = describeRoute({
+    summary: "Initialize ComPilot signer for NFT Fractions market",
+    description: "Returns transaction data for initializing the ComPilot signer on an NFT Fractions market. " +
+        "This must be called after deploying the market to enable compliance gating.",
+    tags: ["NFT Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for initializing ComPilot signer",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+/**
+ * Request schema for initializing ComPilot signer
+ */
+export const InitNftFractionsCompilotRequestSchema = z.object({
+    market: AddressSchema.describe("Address of the NFT Fractions market"),
+    signerAddress: AddressSchema.optional().describe("Optional: Override default ComPilot signer address"),
+});
+/**
+ * Controller for initializing ComPilot signer on NFT Fractions market
+ */
+export const InitCompilotV0 = createController({
+    build: (factory) => factory.createApp().get("/", route, validator("query", InitNftFractionsCompilotRequestSchema), async (c) => {
+        const { market, signerAddress } = c.req.valid("query");
+        const signer = signerAddress ?? DEFAULT_COMPILOT_SIGNER;
+        const tx = initCompilotSigner(market, signer);
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/fractions/platforms/initNid.route.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export declare const InitCompilotRequestSchema: z.ZodObject<{
+    market: 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 InitNidV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    market: 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=initNid.route.d.ts.map

package/dist/fractions/platforms/initNid.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initNid.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/platforms/initNid.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsBxB,eAAO,MAAM,yBAAyB;;iBAEpC,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;QASpB,CAAC"}

package/dist/fractions/platforms/initNid.route.js

@@ -0,0 +1,32 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { getEnv } from "@evergonlabs/internal/node/getEnv";
+import { initCompilotSigner } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../common/index.js";
+const route = describeRoute({
+    summary: "Deploy a market with continuous withdraw",
+    description: "Returns transaction data for deploying a market with continuous withdraw capability",
+    tags: ["Markets"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a market with continuous withdraw",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const InitCompilotRequestSchema = z.object({
+    market: AddressSchema,
+});
+export const InitNidV0 = createController({
+    build: (factory) => factory.createApp().get("/", route, validator("query", InitCompilotRequestSchema), async (c) => {
+        const { market } = c.req.valid("query");
+        const tx = initCompilotSigner(market, getEnv("PLATFORM_COMPILOT_SIGNER", DEFAULT_COMPILOT_SIGNER));
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/fractions/purchase/v0/purchase.route.d.ts

@@ -2,19 +2,19 @@ import { Env } from "hono";
 import { Factory } from "hono/factory";
 import { z } from "zod";
 export declare const PurchaseRequestSchema: z.ZodObject<{
-    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    chainId: z.ZodPipeline<z.ZodEffects<z.ZodType<1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080", z.ZodTypeDef, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, 1 | 31337 | 11155111 | 72080, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, z.ZodType<1 | 31337 | 11155111 | 72080, z.ZodTypeDef, 1 | 31337 | 11155111 | 72080>>;
     market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
     campaignId: z.ZodBigInt;
     amountToBuy: z.ZodBigInt;
     applyDiscount: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    chainId: 1 | 31337 | 11155111 | 72080;
     campaignId: bigint;
     market: `0x${string}`;
     amountToBuy: bigint;
     applyDiscount: boolean;
 }, {
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
     campaignId: bigint;
     market: `0x${string}`;
     amountToBuy: bigint;
@@ -32,7 +32,7 @@ export declare function createPurchaseSalesTransactionV0<E extends Env>(factory:
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
     in: {
         json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
             campaignId: bigint;
             market: `0x${string}`;
             amountToBuy: bigint;
@@ -41,7 +41,7 @@ export declare function createPurchaseSalesTransactionV0<E extends Env>(factory:
     };
     out: {
         json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 31337 | 11155111 | 72080;
             campaignId: bigint;
             market: `0x${string}`;
             amountToBuy: bigint;
@@ -60,7 +60,7 @@ export declare function createPurchaseSalesTransactionV0<E extends Env>(factory:
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
     in: {
         json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
             campaignId: bigint;
             market: `0x${string}`;
             amountToBuy: bigint;
@@ -69,7 +69,7 @@ export declare function createPurchaseSalesTransactionV0<E extends Env>(factory:
     };
     out: {
         json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 31337 | 11155111 | 72080;
             campaignId: bigint;
             market: `0x${string}`;
             amountToBuy: bigint;

package/dist/fractions/purchase/v0/purchase.route.js

@@ -1,11 +1,11 @@
 import { resolver, validator } from "hono-openapi/zod";
 import { describeRoute } from "hono-openapi";
 import { buildPurchaseTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { TmiChainIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { FractionsChainId, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { z } from "zod";
 import { AddressSchema } from "@evergonlabs/tmi-protocol-types/evm";
 export const PurchaseRequestSchema = z.object({
-    chainId: TmiChainIdSchema,
+    chainId: FractionsChainId,
     market: AddressSchema,
     campaignId: z.coerce.bigint(),
     amountToBuy: z.coerce.bigint(),