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

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

@@ -0,0 +1,75 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { buildRequestWithdrawalTx, buildWithdrawFundsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+// ──────────────────────────── Request Withdrawal (step 1) ─────────────────────
+const RequestWithdrawalRequestSchema = z
+    .object({
+    market: AddressSchema.describe("Address of the Vesting & Redemption Dynamic market"),
+    campaignId: Int256BigInt(z.bigint().nonnegative()).describe("Campaign ID"),
+    amountOfFractions: Int256BigInt(z.bigint().positive()).describe("Number of ERC-20 fractions to burn (in raw token units with 18 decimals). " +
+        "The fractions are burned and a withdrawal receipt NFT is issued."),
+})
+    .openapi("RequestWithdrawalRequestSchema");
+const requestWithdrawalRoute = describeRoute({
+    summary: "Withdrawal step 1 — burn fractions and receive withdrawal receipt NFT",
+    description: "Returns transaction data for the first step of the two-click epoch withdrawal flow. " +
+        "The investor burns their ERC-20 fractions and receives a withdrawal receipt NFT. " +
+        "The investor can then redeem the receipt NFT for funds in the next or any later epoch.",
+    tags: ["Vesting & Redemption Dynamic"],
+    responses: {
+        200: {
+            description: "Returns transaction data for requesting a withdrawal",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RequestWithdrawalV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", requestWithdrawalRoute, validator("json", RequestWithdrawalRequestSchema), async (c) => {
+        const { market, campaignId, amountOfFractions } = c.req.valid("json");
+        const tx = buildRequestWithdrawalTx({ market, campaignId, amountOfFractions });
+        return c.json(toTransaction(tx));
+    }),
+});
+// ──────────────────────────── Withdraw Funds (step 2) ─────────────────────────
+const WithdrawFundsRequestSchema = z
+    .object({
+    market: AddressSchema.describe("Address of the Vesting & Redemption Dynamic market"),
+    campaignId: Int256BigInt(z.bigint().nonnegative()).describe("Campaign ID"),
+    nftId: Int256BigInt(z.bigint().nonnegative()).describe("ID of the withdrawal receipt NFT (emitted in the event from step 1)"),
+})
+    .openapi("WithdrawFundsRequestSchema");
+const withdrawRoute = describeRoute({
+    summary: "Withdrawal step 2 — burn withdrawal receipt NFT and receive funds",
+    description: "Returns transaction data for the second step of the two-click epoch withdrawal flow. " +
+        "The investor burns their withdrawal receipt NFT and receives funds at the price of epoch N+1, " +
+        "where N is the epoch in which the withdrawal was requested. " +
+        "This can only be called after the price setter has advanced the epoch at least once since the withdrawal request.",
+    tags: ["Vesting & Redemption Dynamic"],
+    responses: {
+        200: {
+            description: "Returns transaction data for withdrawing funds",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const WithdrawFundsV0 = createController({
+    build: (factory) => factory.createApp().post("/", withdrawRoute, validator("json", WithdrawFundsRequestSchema), async (c) => {
+        const { market, campaignId, nftId } = c.req.valid("json");
+        const tx = buildWithdrawFundsTx({ market, campaignId, nftId });
+        return c.json(toTransaction(tx));
+    }),
+});

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

@@ -0,0 +1,19 @@
+export declare const GetCurrentEpochV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    market: string | string[];
+                    campaignId: string | string[];
+                };
+            };
+            output: {
+                currentEpoch: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getCurrentEpoch.routes.d.ts.map

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

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

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

@@ -0,0 +1,52 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { readContract } from "viem/actions";
+import { z } from "zod";
+import { buildGetCurrentEpochCall } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, NextFractionsChainId } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+const QuerySchema = z.object({
+    chainId: NextFractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    market: AddressSchema.openapi({
+        param: { name: "market", in: "query" },
+        description: "Address of the Vesting & Redemption Dynamic market",
+    }),
+    campaignId: Int256BigInt().openapi({
+        param: { name: "campaignId", in: "query" },
+        description: "Campaign ID",
+    }),
+});
+export const GetCurrentEpochV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get current epoch",
+        description: "Returns the current epoch number for a Vesting & Redemption Dynamic campaign.",
+        tags: ["Vesting & Redemption Dynamic"],
+        responses: {
+            200: {
+                description: "Returns the current epoch number",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            currentEpoch: Int256Json.openapi({ description: "Current epoch number", example: "1" }),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const { chainId, market, campaignId } = c.req.valid("query");
+        const publicClient = getPublicClient(chainId, c.env.config);
+        // account must be the diamond address itself so msg.sender == address(this),
+        // satisfying the OnlyInternalDelegateCall modifier on the facet.
+        const result = await readContract(publicClient, {
+            ...buildGetCurrentEpochCall(market, campaignId),
+            account: market,
+        });
+        return c.json({ currentEpoch: result.toString() }, 200);
+    }),
+});

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

@@ -0,0 +1,23 @@
+export declare const GetEpochPurchaseEventV0: 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;
+                nftId: string;
+                purchaser: `0x${string}`;
+                amountProvided: string;
+                amountAfterFees: string;
+                epochPurchased: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getEpochPurchaseEvent.routes.d.ts.map

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

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

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

@@ -0,0 +1,67 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { parseNftPurchasedEvent } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+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, HashSchema, NextFractionsChainId } from "../../../common/index.js";
+const QuerySchema = z.object({
+    chainId: NextFractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    hash: HashSchema.openapi({
+        param: { name: "hash", in: "query" },
+    }),
+});
+export const GetEpochPurchaseEventV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get NftPurchased event",
+        description: "Gets the transaction by hash and parses the `NftPurchased` event emitted during step 1 of the two-click epoch purchase flow.",
+        tags: ["Vesting & Redemption Dynamic"],
+        responses: {
+            200: {
+                description: "Returns parsed NftPurchased event data",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            campaignId: Int256Json.openapi({ description: "Campaign ID", example: "1" }),
+                            nftId: Int256Json.openapi({ description: "Purchase receipt NFT ID" }),
+                            purchaser: AddressSchema,
+                            amountProvided: Int256Json,
+                            amountAfterFees: Int256Json,
+                            epochPurchased: Int256Json,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        const result = parseNftPurchasedEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParseNftPurchasedEvent();
+        }
+        return c.json({
+            campaignId: result.campaignId.toString(),
+            nftId: result.nftId.toString(),
+            purchaser: result.purchaser,
+            amountProvided: result.amountProvided.toString(),
+            amountAfterFees: result.amountAfterFees.toString(),
+            epochPurchased: result.epochPurchased.toString(),
+        }, 200);
+    }),
+});
+class UnableParseNftPurchasedEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse NftPurchased event. Make sure you're passing a transaction hash from a VRD purchase (step 1).`,
+            name: "UnableParseNftPurchasedEvent",
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+export declare const GetPurchasePriceForEpochV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    market: string | string[];
+                    campaignId: string | string[];
+                    epoch: string | string[];
+                };
+            };
+            output: {
+                price: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getPurchasePriceForEpoch.routes.d.ts.map

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

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

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

@@ -0,0 +1,59 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { readContract } from "viem/actions";
+import { z } from "zod";
+import { buildGetPurchasePriceForEpochCall } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, NextFractionsChainId } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+const QuerySchema = z.object({
+    chainId: NextFractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    market: AddressSchema.openapi({
+        param: { name: "market", in: "query" },
+        description: "Address of the Vesting & Redemption Dynamic market",
+    }),
+    campaignId: Int256BigInt().openapi({
+        param: { name: "campaignId", in: "query" },
+        description: "Campaign ID",
+    }),
+    epoch: Int256BigInt().openapi({
+        param: { name: "epoch", in: "query" },
+        description: "Epoch number to query the price for",
+    }),
+});
+export const GetPurchasePriceForEpochV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get purchase price for epoch",
+        description: "Returns the purchase price (in funding packets per 10^18 fraction token units) recorded for a specific epoch in a Vesting & Redemption Dynamic campaign.",
+        tags: ["Vesting & Redemption Dynamic"],
+        responses: {
+            200: {
+                description: "Returns the epoch price",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            price: Int256Json.openapi({
+                                description: "Price in funding packets per 10^18 fraction token units",
+                                example: "1000000000000000000",
+                            }),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const { chainId, market, campaignId, epoch } = c.req.valid("query");
+        const publicClient = getPublicClient(chainId, c.env.config);
+        // account must be the diamond address itself so msg.sender == address(this),
+        // satisfying the OnlyInternalDelegateCall modifier on the facet.
+        const result = await readContract(publicClient, {
+            ...buildGetPurchasePriceForEpochCall(market, campaignId, epoch),
+            account: market,
+        });
+        return c.json({ price: result.toString() }, 200);
+    }),
+});

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

@@ -0,0 +1,21 @@
+export declare const GetWithdrawalRequestedEventV0: 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;
+                nftId: string;
+                requester: `0x${string}`;
+                amountOfFractions: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getWithdrawalRequestedEvent.routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getWithdrawalRequestedEvent.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/vestingRedemptionDynamic/getWithdrawalRequestedEvent.routes.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;aAgDxC,CAAC"}

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

@@ -0,0 +1,63 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { parseWithdrawalRequestedEvent } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+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, HashSchema, NextFractionsChainId } from "../../../common/index.js";
+const QuerySchema = z.object({
+    chainId: NextFractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    hash: HashSchema.openapi({
+        param: { name: "hash", in: "query" },
+    }),
+});
+export const GetWithdrawalRequestedEventV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get WithdrawalRequested event",
+        description: "Gets the transaction by hash and parses the `WithdrawalRequested` event emitted during step 1 of the two-click epoch withdrawal flow.",
+        tags: ["Vesting & Redemption Dynamic"],
+        responses: {
+            200: {
+                description: "Returns parsed WithdrawalRequested event data",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            campaignId: Int256Json.openapi({ description: "Campaign ID", example: "1" }),
+                            nftId: Int256Json.openapi({ description: "Withdrawal receipt NFT ID" }),
+                            requester: AddressSchema,
+                            amountOfFractions: Int256Json,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        const result = parseWithdrawalRequestedEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParseWithdrawalRequestedEvent();
+        }
+        return c.json({
+            campaignId: result.campaignId.toString(),
+            nftId: result.nftId.toString(),
+            requester: result.requester,
+            amountOfFractions: result.amountOfFractions.toString(),
+        }, 200);
+    }),
+});
+class UnableParseWithdrawalRequestedEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse WithdrawalRequested event. Make sure you're passing a transaction hash from a VRD requestWithdrawal (step 1).`,
+            name: "UnableParseWithdrawalRequestedEvent",
+        });
+    }
+}