@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

@@ -1,7 +1,7 @@
 import { Factory } from "hono/factory";
 import { AppContext } from "../../../common/context.js";
 export declare function createPurchaseSalesStatisticsV0(factory: Factory<AppContext>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    chainId: 1 | 31337 | 11155111 | 72080;
     campaignId: string;
     platform: `0x${string}`;
     statistics: {
@@ -15,7 +15,7 @@ export declare function createPurchaseSalesStatisticsV0(factory: Factory<AppCont
             walletAddress: `0x${string}`;
             campaignId: string | number | bigint;
             platform: `0x${string}`;
-            chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+            chainId?: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080" | undefined;
         };
     };
     out: {
@@ -23,11 +23,11 @@ export declare function createPurchaseSalesStatisticsV0(factory: Factory<AppCont
             walletAddress: `0x${string}`;
             campaignId: bigint;
             platform: `0x${string}`;
-            chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+            chainId?: 1 | 31337 | 11155111 | 72080 | undefined;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    chainId: 1 | 31337 | 11155111 | 72080;
     campaignId: string;
     platform: `0x${string}`;
     statistics: {
@@ -41,7 +41,7 @@ export declare function createPurchaseSalesStatisticsV0(factory: Factory<AppCont
             walletAddress: `0x${string}`;
             campaignId: string | number | bigint;
             platform: `0x${string}`;
-            chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+            chainId?: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080" | undefined;
         };
     };
     out: {
@@ -49,11 +49,11 @@ export declare function createPurchaseSalesStatisticsV0(factory: Factory<AppCont
             walletAddress: `0x${string}`;
             campaignId: bigint;
             platform: `0x${string}`;
-            chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+            chainId?: 1 | 31337 | 11155111 | 72080 | undefined;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    chainId: 1 | 31337 | 11155111 | 72080;
     campaignId: string;
     platform: `0x${string}`;
     statistics: {

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

@@ -2,7 +2,7 @@ import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { and, count, eq, sum } from "@ponder/client";
 import { FractionsSaleStatisticSchema } from "../../sales/getFractionSaleStatistics.route.js";
-import { AddressSchema, CampaignIdSchema, PlatformContractAddress, TmiChainIdSchema } from "../../../common/index.js";
+import { AddressSchema, CampaignIdSchema, PlatformContractAddress, FractionsChainId } from "../../../common/index.js";
 import { z } from "../../../common/zod.js";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
 export function createPurchaseSalesStatisticsV0(factory) {
@@ -21,7 +21,7 @@ export function createPurchaseSalesStatisticsV0(factory) {
             },
         },
     }), validator("json", z.object({
-        chainId: TmiChainIdSchema.optional(),
+        chainId: FractionsChainId.optional(),
         platform: PlatformContractAddress,
         campaignId: CampaignIdSchema,
         walletAddress: AddressSchema,

package/dist/fractions/roles/getRoles.d.ts

@@ -0,0 +1,23 @@
+export declare const GetFractionsRolesV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: ({
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            })[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=getRoles.d.ts.map

package/dist/fractions/roles/getRoles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRoles.d.ts","sourceRoot":"","sources":["../../../src/fractions/roles/getRoles.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;QAqB9B,CAAC"}

package/dist/fractions/roles/getRoles.js

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver } from "hono-openapi";
+import { z } from "zod";
+import { FractionsRole, getFractionsRole } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { RoleSchema } from "../../staking/roles/common/role.js";
+export const GetFractionsRolesV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get roles",
+        description: "Retrieve all available (pre-defined) roles",
+        tags: ["Roles"],
+        responses: {
+            200: {
+                description: "List of available roles",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(RoleSchema)),
+                    },
+                },
+            },
+        },
+    }), (c) => c.json(allRoles, 200)),
+});
+const roleByRole = {
+    [FractionsRole.Admin]: {
+        name: "Admin",
+        value: getFractionsRole(FractionsRole.Admin),
+    },
+    [FractionsRole.Open]: {
+        name: "Open",
+        value: getFractionsRole(FractionsRole.Open),
+    },
+    [FractionsRole.Issuer]: {
+        name: "Issuer",
+        value: getFractionsRole(FractionsRole.Issuer),
+    },
+    [FractionsRole.Buyer]: {
+        name: "Buyer",
+        value: getFractionsRole(FractionsRole.Buyer),
+    },
+};
+const allRoles = Object.values(roleByRole);

package/dist/fractions/roles/grantRole.route.d.ts

@@ -0,0 +1,27 @@
+export declare const GrantFractionsRoleV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    marketAddress: string;
+                    users: string[];
+                    role: import("@evergonlabs/tmi-protocol-fractions-sdk").RoleTypeEnum;
+                };
+            };
+            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=grantRole.route.d.ts.map

package/dist/fractions/roles/grantRole.route.d.ts.map

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

package/dist/fractions/roles/grantRole.route.js

@@ -0,0 +1,34 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildGrantRoleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
+import { GrantMarketRoleRequestSchema } from "./grantRole.schema.js";
+const route = describeRoute({
+    summary: "Grant a role",
+    description: "Returns transaction data for granting a role in a market",
+    tags: ["Roles"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a market",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const GrantFractionsRoleV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", GrantMarketRoleRequestSchema.openapi("GrantMarketRoleRequestSchema")), async (c) => {
+        const { role, users, marketAddress } = c.req.valid("json");
+        const tx = buildGrantRoleTx({
+            role,
+            users,
+            marketAddress,
+        });
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/fractions/roles/grantRole.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { RoleTypeEnum } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export declare const RoleTypeEnumSchema: z.ZodEnum<{
+    readonly ISSUER: RoleTypeEnum.ISSUER;
+    readonly BUYER: RoleTypeEnum.INVESTOR;
+}>;
+export declare const GrantMarketRoleRequestSchema: z.ZodObject<{
+    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>[]]>>;
+    marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    users: z.ZodArray<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    role: z.ZodEnum<{
+        readonly ISSUER: RoleTypeEnum.ISSUER;
+        readonly BUYER: RoleTypeEnum.INVESTOR;
+    }>;
+}, z.core.$strip>;
+//# sourceMappingURL=grantRole.schema.d.ts.map

package/dist/fractions/roles/grantRole.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.schema.d.ts","sourceRoot":"","sources":["../../../src/fractions/roles/grantRole.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAQvE,eAAO,MAAM,kBAAkB;;;EAAgC,CAAC;AAEhE,eAAO,MAAM,4BAA4B;;;;;;;;iBAKvC,CAAC"}

package/dist/fractions/roles/grantRole.schema.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { RoleTypeEnum } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, FractionsChainId } from "../../common/index.js";
+const RoleTypeLimited = {
+    ISSUER: RoleTypeEnum.ISSUER,
+    BUYER: RoleTypeEnum.INVESTOR,
+};
+export const RoleTypeEnumSchema = z.nativeEnum(RoleTypeLimited);
+export const GrantMarketRoleRequestSchema = z.object({
+    chainId: FractionsChainId,
+    marketAddress: AddressSchema,
+    users: AddressSchema.array(),
+    role: RoleTypeEnumSchema,
+});

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

@@ -0,0 +1,48 @@
+export declare const RolesController: 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: ({
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            })[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    marketAddress: string;
+                    users: string[];
+                    role: import("@evergonlabs/tmi-protocol-fractions-sdk").RoleTypeEnum;
+                };
+            };
+            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;
+        };
+    };
+}, "/grant">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/fractions/roles/index.js

@@ -0,0 +1,9 @@
+import { createController } from "../../common/controller.js";
+import { GetFractionsRolesV0 } from "./getRoles.js";
+import { GrantFractionsRoleV0 } from "./grantRole.route.js";
+export const RolesController = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/", GetFractionsRolesV0.build(factory))
+        .route("/grant", GrantFractionsRoleV0.build(factory)),
+});

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { FractionSaleEventEnum, FractionSaleStatusEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+export declare const FractionActivityEntrySchema: z.ZodObject<{
+    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>[]]>>;
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    transactionHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    from: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    metadata: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.CREATED>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.STATUS_UPDATE>;
+        status: z.ZodEnum<typeof FractionSaleStatusEnum>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.PURCHASE>;
+        purchaser: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        priceId: z.ZodString;
+        amountOfFractions: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        amountPaid: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        amountBurnt: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.CLAIM>;
+        receiver: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        claimId: z.ZodString;
+        fractionsBurnt: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        received: z.ZodArray<z.ZodObject<{
+            tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+            amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+            tokenId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.REFUND>;
+        amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.WITHDRAW>;
+        amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.WITHDRAW_NON_WRAPPED>;
+        receiver: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        received: z.ZodArray<z.ZodObject<{
+            tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+            amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+            tokenId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+//# sourceMappingURL=activityUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activityUtils.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/activityUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAgEzG,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYT,CAAC"}

package/dist/fractions/sales/activityUtils.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { FractionSaleEventEnum, FractionSaleStatusEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { AddressSchema, TransactionHashSchema } from "@evergonlabs/tmi-utils/models";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { FractionsChainId, PlatformContractAddress } from "../../common/index.js";
+import { ISOJson } from "../../common/models/date.js";
+const baseSchema = z.object({
+    chainId: FractionsChainId,
+    platform: PlatformContractAddress,
+    campaignId: Int256Json,
+    transactionHash: TransactionHashSchema,
+    from: AddressSchema,
+    createdAt: ISOJson,
+    updatedAt: ISOJson,
+});
+const wrappedAssetAmountSchema = z.object({
+    tokenAddress: AddressSchema,
+    amount: Int256Json,
+    tokenId: Int256Json,
+});
+const createdEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.CREATED),
+});
+const stateChangedEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.STATUS_UPDATE),
+    status: z.enum(FractionSaleStatusEnum),
+});
+const purchaseEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.PURCHASE),
+    purchaser: AddressSchema,
+    priceId: z.string(),
+    amountOfFractions: Int256Json,
+    amountPaid: Int256Json,
+    amountBurnt: Int256Json,
+});
+const claimEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.CLAIM),
+    receiver: AddressSchema,
+    claimId: z.string(),
+    fractionsBurnt: Int256Json,
+    received: z.array(wrappedAssetAmountSchema),
+});
+const refundEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.REFUND),
+    amount: Int256Json,
+});
+const withdrawEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.WITHDRAW),
+    amount: Int256Json,
+});
+const withdrawNonWrappedEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.WITHDRAW_NON_WRAPPED),
+    receiver: AddressSchema,
+    received: z.array(wrappedAssetAmountSchema),
+});
+export const FractionActivityEntrySchema = baseSchema
+    .extend({
+    metadata: z.discriminatedUnion("type", [
+        createdEventSchema,
+        stateChangedEventSchema,
+        purchaseEventSchema,
+        claimEventSchema,
+        refundEventSchema,
+        withdrawEventSchema,
+        withdrawNonWrappedEventSchema,
+    ]),
+})
+    .openapi("FractionsActivity");

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const ApproveSaleRequestSchema: z.ZodObject<{
+    marketAddress: 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 ApproveSaleV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    marketAddress: 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=approveSale.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"approveSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveSale.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;QASxB,CAAC"}

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

@@ -0,0 +1,35 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { buildApproveSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+export const ApproveSaleRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    campaignId: Int256BigInt(z.bigint().nonnegative()),
+});
+const route = describeRoute({
+    summary: "Approve a sale",
+    description: "Returns transaction data for approving a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a sale",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const ApproveSaleV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", ApproveSaleRequestSchema.openapi("ApproveSaleRequestSchema")), async (c) => {
+        const { marketAddress, campaignId } = c.req.valid("json");
+        const tx = buildApproveSaleTx({ market: marketAddress, campaignId: campaignId });
+        return c.json(toTransaction(tx));
+    }),
+});