@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

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

package/dist/fractions/sales/index.js

@@ -0,0 +1,52 @@
+import { createController } from "../../common/controller.js";
+import { SearchSalesV0 } from "./searchSales/searchSales.js";
+import { ClaimStatisticsV0 } from "./vesting/claimStatistics.route.js";
+import { ClaimVestedTokensV0 } from "./vesting/claimVestedTokens.route.js";
+import { EditCliffV0 } from "./vesting/editCliff.route.js";
+import { ParseClaimVestedTokensEventV0 } from "./vesting/parseClaimVestedTokensEvent.js";
+import { ApproveSaleV0 } from "./approveSale.route.js";
+import { CompleteSaleV0 } from "./completeSale.route.js";
+import { CreateFractionsV0 } from "./createFractions.route.js";
+import { GetFractionSaleStatisticsV0 } from "./getFractionSaleStatistics.route.js";
+import { GetVaultAddressV0 } from "./getVaultAddress.js";
+import { GetWithdrawEventV0 } from "./getWithdrawEvent.js";
+import { ParseFractionsCreatedEventV0 } from "./parseFractionsCreatedEvent.js";
+import { PurchaseV0 } from "./purchase.route.js";
+import { PurchaseStatisticsV0 } from "./purchaseStatistics.route.js";
+import { CheckAndJumpToNonFundedV0, ReceiveFundsAfterNonFundedV0 } from "./receiveFundsAfterNonFunded.route.js";
+import { ReceiveNonPurchasedWrappedAssetsV0 } from "./receiveNonPurchasedWrappedAssets.route.js";
+import { RecoverFractionsV0 } from "./recoverFractions.js";
+import { RejectFractionsV0 } from "./rejectFractions.js";
+import { SearchActivityV0 } from "./searchActivity.route.js";
+import { SearchWithdrawalV0 } from "./searchWithdrawal.route.js";
+import { SetFeeCapLimitV0 } from "./setFeeCapLimit.js";
+import { UnlockWrappedAssetsV0 } from "./unlockWrappedAssets.route.js";
+import { WithdrawV0 } from "./withdraw.route.js";
+export const SalesController = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/fractions", CreateFractionsV0.build(factory))
+        .route("/getFractionsCreatedEvent", ParseFractionsCreatedEventV0.build(factory))
+        .route("/approve", ApproveSaleV0.build(factory))
+        .route("/reject", RejectFractionsV0.build(factory))
+        .route("/recover", RecoverFractionsV0.build(factory))
+        .route("/complete", CompleteSaleV0.build(factory))
+        .route("/unlockWrappedAssets", UnlockWrappedAssetsV0.build(factory))
+        .route("/purchase", PurchaseV0.build(factory))
+        .route("/purchase/statistics", PurchaseStatisticsV0.build(factory))
+        .route("/withdraw/search", SearchWithdrawalV0.build(factory))
+        .route("/withdrawPaymentToken", WithdrawV0.build(factory))
+        .route("/receiveFundsAfterNonFunded", ReceiveFundsAfterNonFundedV0.build(factory))
+        .route("/checkAndJumpToNonFunded", CheckAndJumpToNonFundedV0.build(factory))
+        .route("/receiveNonPurchasedWrappedAssets", ReceiveNonPurchasedWrappedAssetsV0.build(factory))
+        .route("/vesting/editCliff", EditCliffV0.build(factory))
+        .route("/vesting/claim", ClaimVestedTokensV0.build(factory))
+        .route("/vesting/claim/statistics", ClaimStatisticsV0.build(factory))
+        .route("/vesting/getClaimVestedTokensEvent", ParseClaimVestedTokensEventV0.build(factory))
+        .route("/search", SearchSalesV0.build(factory))
+        .route("/activity", SearchActivityV0.build(factory))
+        .route("/statistics", GetFractionSaleStatisticsV0.build(factory))
+        .route("/setFeeCapLimit", SetFeeCapLimitV0.build(factory))
+        .route("/getWithdrawEvent", GetWithdrawEventV0.build(factory))
+        .route("/getVaultAddress", GetVaultAddressV0.build(factory)),
+});

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

@@ -0,0 +1,23 @@
+export declare const ParseFractionsCreatedEventV0: 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/fractions/sales/parseFractionsCreatedEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFractionsCreatedEvent.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/parseFractionsCreatedEvent.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;QAmDvC,CAAC"}

package/dist/fractions/sales/parseFractionsCreatedEvent.js

@@ -0,0 +1,59 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { parseFractionsCreatedEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { getPublicClient } from "../../common/blockchain.js";
+import { createController } from "../../common/controller.js";
+import { HttpError } from "../../common/http-error.js";
+import { AddressSchema, SentTransactionParamsSchema } from "../../common/index.js";
+export const ParseFractionsCreatedEventV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get FractionsCreated Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`createFractions\` action`,
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            creator: AddressSchema,
+                            nftId: Int256Json,
+                            campaignId: Int256Json.openapi({ description: "Id of a Sale", example: "1" }),
+                            fractionsCreated: Int256Json,
+                            fractionsAddress: AddressSchema,
+                            vaultAddress: AddressSchema,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        const result = parseFractionsCreatedEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParseFractionsCreatedEvent();
+        }
+        return c.json({
+            campaignId: result.campaignId.toString(),
+            creator: result.creator,
+            nftId: result.wrapperNftId.toString(),
+            fractionsCreated: result.fractionsCreated.toString(),
+            fractionsAddress: result.fractionsAddress,
+            vaultAddress: result.vaultAddress,
+        }, 200);
+    }),
+});
+class UnableParseFractionsCreatedEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse FractionsCreated transaction. Make sure you're passing transaction that is generated by \`createFractions\` action`,
+            name: "UnableParseFractionsCreatedEvent",
+        });
+    }
+}

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const PurchaseRequestSchema: z.ZodObject<{
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 72080>[]]>>;
+    amountToBuy: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    applyDiscount: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const PurchaseV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=purchase.route.d.ts.map

package/dist/fractions/sales/purchase.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/purchase.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,qBAAqB;;;;;;iBAIhC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;QAgBrB,CAAC"}

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

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { buildPurchaseTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { FractionsChainId, SaleIdSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+export const PurchaseRequestSchema = SaleIdSchema.extend({
+    chainId: FractionsChainId,
+    amountToBuy: Int256BigInt(),
+    applyDiscount: z.boolean(),
+});
+const route = describeRoute({
+    summary: "Make a purchase",
+    description: "Returns transaction data for making a purchase",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for making a purchase",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const PurchaseV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", PurchaseRequestSchema.openapi("PurchaseRequestSchema")), async (c) => {
+        const { chainId, market, campaignId, amountToBuy, applyDiscount } = c.req.valid("json");
+        const tx = buildPurchaseTx(chainId, {
+            market: market,
+            campaignId: campaignId,
+            amountToBuy: amountToBuy,
+            //todo burn for discount will be changed when multiple discount options becomes available in smart contract
+            discount: applyDiscount ? { burnForDiscount: BigInt(1) } : undefined,
+        });
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/fractions/sales/purchaseStatistics.route.d.ts

@@ -0,0 +1,27 @@
+export declare const PurchaseStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    campaignId: string;
+                    walletAddress: string;
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                chainId: 1 | 11155111 | 31337 | 72080;
+                platform: `0x${string}`;
+                campaignId: string;
+                statistics: {
+                    priceId: string;
+                    fractionsSold: string;
+                    purchases: number;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=purchaseStatistics.route.d.ts.map

package/dist/fractions/sales/purchaseStatistics.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchaseStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/purchaseStatistics.route.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;QAqE/B,CAAC"}

package/dist/fractions/sales/purchaseStatistics.route.js

@@ -0,0 +1,53 @@
+import { and, count, eq, sum } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { FractionsSaleStatisticSchema } from "./getFractionSaleStatistics.route.js";
+export const PurchaseStatisticsV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Aggregate investor statistics for certain campaign",
+        description: "Returns aggregated statistics about investor purchases for a specific campaign, grouped by price ID. Statistics include the number of purchases and the total number of fractions sold.",
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Aggregated purchase statistics for the specified campaign and investor.",
+                content: {
+                    "application/json": {
+                        schema: resolver(FractionsSaleStatisticSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        chainId: FractionsChainId.optional(),
+        platform: PlatformContractAddress,
+        campaignId: CampaignIdSchema,
+        walletAddress: AddressSchema,
+    })), async (c) => {
+        const { chainId, platform, campaignId, walletAddress } = c.req.valid("json");
+        const { fractions: { fractionsPurchases }, } = indexerSchemas;
+        const rows = await c
+            .get("indexerClient")
+            .db.select({
+            purchases: count(fractionsPurchases.transactionHash),
+            fractionsSold: sum(fractionsPurchases.amountOfFractions),
+            priceId: fractionsPurchases.priceId,
+        })
+            .from(fractionsPurchases)
+            .where(and(eq(fractionsPurchases.chainId, Number(chainId)), eq(fractionsPurchases.diamondAddress, platform), eq(fractionsPurchases.saleId, BigInt(campaignId)), eq(fractionsPurchases.buyerAddress, walletAddress)))
+            .groupBy(fractionsPurchases.priceId);
+        const statistics = rows.map((r) => ({
+            ...r,
+            fractionsSold: r.fractionsSold || "0",
+        }));
+        return c.json(FractionsSaleStatisticSchema.parse({
+            chainId: chainId,
+            platform: platform,
+            campaignId: campaignId,
+            statistics,
+        }), 200);
+    }),
+});

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.d.ts

@@ -1,144 +1,60 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
 import { z } from "zod";
 export declare const ReceiveFundsAfterNonFundedRequestSchema: z.ZodObject<{
-    upperGenesisId: z.ZodOptional<z.ZodBigInt>;
-    amountOfFractions: z.ZodBigInt;
+    upperGenesisId: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    amountOfFractions: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
     isDiscounted: z.ZodBoolean;
-} & {
-    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodBigInt;
-}, "strip", z.ZodTypeAny, {
-    campaignId: bigint;
-    amountOfFractions: bigint;
-    market: `0x${string}`;
-    isDiscounted: boolean;
-    upperGenesisId?: bigint | undefined;
-}, {
-    campaignId: bigint;
-    amountOfFractions: bigint;
-    market: `0x${string}`;
-    isDiscounted: boolean;
-    upperGenesisId?: bigint | undefined;
-}>;
-export declare function createReceiveFundsAfterNonFundedTransaction<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            campaignId: bigint;
-            amountOfFractions: bigint;
-            market: `0x${string}`;
-            isDiscounted: boolean;
-            upperGenesisId?: bigint | undefined;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            amountOfFractions: bigint;
-            market: `0x${string}`;
-            isDiscounted: boolean;
-            upperGenesisId?: bigint | undefined;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: 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: {
-            campaignId: bigint;
-            amountOfFractions: bigint;
-            market: `0x${string}`;
-            isDiscounted: boolean;
-            upperGenesisId?: bigint | undefined;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            amountOfFractions: bigint;
-            market: `0x${string}`;
-            isDiscounted: boolean;
-            upperGenesisId?: bigint | undefined;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-export declare function createCheckAndJumpToNonFundedTransaction<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: 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: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const ReceiveFundsAfterNonFundedV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    amountOfFractions: string;
+                    isDiscounted: boolean;
+                    market: string;
+                    campaignId: string;
+                    upperGenesisId?: 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;
+        };
+    };
+}, "/">>;
+export declare const CheckAndJumpToNonFundedV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    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;
+        };
+    };
+}, "/">>;
 //# sourceMappingURL=receiveFundsAfterNonFunded.route.d.ts.map

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"receiveFundsAfterNonFunded.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveFundsAfterNonFunded.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAkB9B,wBAAgB,2CAA2C,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAe7F;AAkBD,wBAAgB,wCAAwC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAM1F"}
+{"version":3,"file":"receiveFundsAfterNonFunded.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveFundsAfterNonFunded.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,uCAAuC;;;;;;iBAMvB,CAAC;AAkB9B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;QAgBvC,CAAC;AAkBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;QAOpC,CAAC"}

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.js

@@ -1,13 +1,15 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { receiveFundsAfterNonFundedNoDiscount, receiveFundsAfterNonFundedDiscount, checkAndJumpToNonFunded, } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { toTransaction, TransactionSchema } from "../../common/index.js";
+import { resolver, validator } from "hono-openapi";
 import { z } from "zod";
+import { checkAndJumpToNonFunded, receiveFundsAfterNonFundedDiscount, receiveFundsAfterNonFundedNoDiscount, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
 import { SaleIdSchema } from "../../common/models/saleId.js";
 export const ReceiveFundsAfterNonFundedRequestSchema = z
     .object({
-    upperGenesisId: z.coerce.bigint().optional().openapi({ description: "Required if discount was applied" }),
-    amountOfFractions: z.coerce.bigint(),
+    upperGenesisId: Int256BigInt().optional().openapi({ description: "Required if discount was applied" }),
+    amountOfFractions: Int256BigInt(),
     isDiscounted: z.boolean(),
 })
     .extend(SaleIdSchema.shape);
@@ -26,15 +28,17 @@ const route = describeRoute({
         },
     },
 });
-export function createReceiveFundsAfterNonFundedTransaction(factory) {
-    return factory.createHandlers(route, validator("json", ReceiveFundsAfterNonFundedRequestSchema.openapi({ ref: "ReceiveFundsAfterNonFundedRequestSchema" })), async (c) => {
+export const ReceiveFundsAfterNonFundedV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", ReceiveFundsAfterNonFundedRequestSchema.openapi("ReceiveFundsAfterNonFundedRequestSchema")), async (c) => {
         const { market, campaignId, amountOfFractions, upperGenesisId, isDiscounted } = c.req.valid("json");
         const tx = isDiscounted
-            ? receiveFundsAfterNonFundedDiscount(market, campaignId, upperGenesisId, amountOfFractions)
-            : receiveFundsAfterNonFundedNoDiscount(market, campaignId, amountOfFractions);
+            ? receiveFundsAfterNonFundedDiscount(market, BigInt(campaignId), upperGenesisId, amountOfFractions)
+            : receiveFundsAfterNonFundedNoDiscount(market, BigInt(campaignId), amountOfFractions);
         return c.json(toTransaction(tx));
-    });
-}
+    }),
+});
 const checkAndJumpToNonFundedRoute = describeRoute({
     summary: "Check and jump to non funded state",
     description: "Returns transaction to check and jump a sale to non funded state if conditions are met",
@@ -50,10 +54,10 @@ const checkAndJumpToNonFundedRoute = describeRoute({
         },
     },
 });
-export function createCheckAndJumpToNonFundedTransaction(factory) {
-    return factory.createHandlers(checkAndJumpToNonFundedRoute, validator("json", SaleIdSchema), async (c) => {
+export const CheckAndJumpToNonFundedV0 = createController({
+    build: (factory) => factory.createApp().post("/", checkAndJumpToNonFundedRoute, validator("json", SaleIdSchema), async (c) => {
         const { market, campaignId } = c.req.valid("json");
         const tx = checkAndJumpToNonFunded(market, campaignId);
         return c.json(toTransaction(tx));
-    });
-}
+    }),
+});