@evergonlabs/tmi-protocol-api 0.1.0

package/dist/src/staking/index.d.ts

@@ -0,0 +1,242 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const stakingApi: {
+    name: string;
+    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $get: {
+                input: {
+                    query: {
+                        address: `0x${string}`;
+                        chainId: "11155111" | "31337";
+                    };
+                };
+                output: {
+                    chainId: "11155111" | "31337";
+                    txHash: `0x${string}`;
+                    createdAt: string;
+                    contractAddress: `0x${string}`;
+                    adminAddress: `0x${string}`;
+                    updatedAt: string;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/get"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        filter: {
+                            chainId?: "11155111" | "31337" | undefined;
+                            owner?: `0x${string}` | undefined;
+                        };
+                        page: {
+                            skip: number;
+                            limit: number;
+                        };
+                    };
+                };
+                output: {
+                    chainId: "11155111" | "31337";
+                    txHash: `0x${string}`;
+                    createdAt: string;
+                    contractAddress: `0x${string}`;
+                    adminAddress: `0x${string}`;
+                    updatedAt: string;
+                }[];
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/search">, "/platforms"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        filter: {
+                            chainId?: "11155111" | "31337" | undefined;
+                            platform?: `0x${string}` | undefined;
+                        };
+                        page: {
+                            skip: number;
+                            limit: number;
+                        };
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/searchPools"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $get: {
+                input: {
+                    query: {
+                        chainId: string | string[];
+                        platform: string | string[];
+                        poolId: string | string[];
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/getPool">, "/pools"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        filter: {
+                            chainId?: "11155111" | "31337" | undefined;
+                            platform?: `0x${string}` | undefined;
+                            poolId?: string | number | bigint | undefined;
+                            owner?: `0x${string}` | undefined;
+                        };
+                        page: {
+                            skip: number;
+                            limit: number;
+                        };
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/searchStakes"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        filter: {
+                            chainId?: "11155111" | "31337" | undefined;
+                            platform?: `0x${string}` | undefined;
+                            poolId?: string | number | bigint | undefined;
+                            owner?: `0x${string}` | undefined;
+                        };
+                        page: {
+                            skip: number;
+                            limit: number;
+                        };
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $get: {
+                input: {
+                    query: {
+                        chainId: string | string[];
+                        platform: string | string[];
+                        stakeId: string | string[];
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/getStake">, "/stakes"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $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;
+            };
+        };
+    }, "/getRoles"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        platform: `0x${string}`;
+                        addresses: `0x${string}`[];
+                        role: `0x${string}` | import("@evergonlabs/tmi-protocol-staking-sdk").StakingRole;
+                    };
+                };
+                output: {
+                    data: `0x${string}`;
+                    to: `0x${string}`;
+                    details: {
+                        functionName: string;
+                        address: `0x${string}`;
+                        abi: any[];
+                        args: any[];
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/grantRole"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        filter: {
+                            chainId?: "11155111" | "31337" | undefined;
+                            platform?: `0x${string}` | undefined;
+                            poolId?: string | number | bigint | undefined;
+                            owner?: `0x${string}` | undefined;
+                        };
+                        page: {
+                            skip: number;
+                            limit: number;
+                        };
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/searchRoles"> | import("hono/types").MergeSchemaPath<{
+        "/v0": {
+            $post: {
+                input: {
+                    json: {
+                        filter: {
+                            chainId?: "11155111" | "31337" | undefined;
+                            platform?: `0x${string}` | undefined;
+                            poolId?: string | number | bigint | undefined;
+                            owner?: `0x${string}` | undefined;
+                        };
+                        page: {
+                            skip: number;
+                            limit: number;
+                        };
+                    };
+                };
+                output: never;
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/searchRoleEvents">, "/roles">, "/staking">, "/">;
+    config: {
+        title: string;
+        description: string;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAOvC,eAAO,MAAM,UAAU;;gBAET,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB/C,CAAC"}

package/dist/src/staking/index.js

@@ -0,0 +1,20 @@
+import { createRolesApp } from "./roles/index.js";
+import { createPlatformsApp } from "./platforms/index.js";
+import { createStakesApp } from "./stakes/index.js";
+import { createPoolsApp } from "./pools/index.js";
+import { createApiConfig } from "../common/app.js";
+export const stakingApi = {
+    name: "Staking API",
+    createApp: (factory) => factory
+        .createApp()
+        .route("/staking", factory
+        .createApp()
+        .route("/platforms", createPlatformsApp(factory))
+        .route("/pools", createPoolsApp(factory))
+        .route("/stakes", createStakesApp(factory))
+        .route("/roles", createRolesApp(factory))),
+    config: createApiConfig({
+        title: "Staking API",
+        description: "Staking API for Decentralized finance",
+    }),
+};

package/dist/src/staking/platforms/common/platform.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { indexerSchemas } from "../../../common/indexer/schemas.js";
+export declare const PlatformSchema: z.ZodObject<{
+    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+    txHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    createdAt: z.ZodString;
+    contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    adminAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}, {
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}>;
+export declare function mapToPlatform(diamond: typeof indexerSchemas.diamonds.$inferSelect): z.output<typeof PlatformSchema>;
+//# sourceMappingURL=platform.d.ts.map

package/dist/src/staking/platforms/common/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../../../src/staking/platforms/common/platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;EAWvB,CAAC;AAEL,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,cAAc,CAAC,QAAQ,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CASnH"}

package/dist/src/staking/platforms/common/platform.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
+import { AddressSchema, HashSchema, StakingChainId } from "../../../common/index.js";
+import { ISOSchema } from "../../../common/models/date.js";
+export const PlatformSchema = z
+    .object({
+    chainId: StakingChainId,
+    txHash: HashSchema,
+    createdAt: ISOSchema,
+    contractAddress: AddressSchema,
+    adminAddress: AddressSchema,
+    updatedAt: ISOSchema,
+})
+    .openapi({
+    ref: "Platform",
+});
+export function mapToPlatform(diamond) {
+    return {
+        chainId: StakingChainId.parse(diamond.chainId),
+        txHash: diamond.txHash,
+        contractAddress: diamond.contractAddress,
+        adminAddress: diamond.adminAddress,
+        createdAt: unixToDate(diamond.createdAt).toISOString(),
+        updatedAt: unixToDate(diamond.updatedAt).toISOString(),
+    };
+}

package/dist/src/staking/platforms/common/platformNotFound.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from "@evergonlabs/tmi-utils/errors";
+import { Address } from "viem";
+export declare class PlatformNotFoundError extends CustomError<{
+    chainId: string;
+    contract: Address;
+}> {
+    constructor(chainId: string, contract: Address);
+}
+//# sourceMappingURL=platformNotFound.d.ts.map

package/dist/src/staking/platforms/common/platformNotFound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platformNotFound.d.ts","sourceRoot":"","sources":["../../../../../src/staking/platforms/common/platformNotFound.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,qBAAa,qBAAsB,SAAQ,WAAW,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;gBACY,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO;CAU/C"}

package/dist/src/staking/platforms/common/platformNotFound.js

@@ -0,0 +1,13 @@
+import { CustomError } from "@evergonlabs/tmi-utils/errors";
+export class PlatformNotFoundError extends CustomError {
+    constructor(chainId, contract) {
+        super({
+            name: "PlatformNotFoundError",
+            message: `Platform with address ${contract} in ${chainId} network is not found`,
+            data: {
+                chainId: chainId,
+                contract: contract,
+            },
+        });
+    }
+}

package/dist/src/staking/platforms/getPlatform/index.d.ts

@@ -0,0 +1,26 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITag } from "../../../common/tag.js";
+export declare function createGetPlatformApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
+    "/v0": {
+        $get: {
+            input: {
+                query: {
+                    address: `0x${string}`;
+                    chainId: "11155111" | "31337";
+                };
+            };
+            output: {
+                chainId: "11155111" | "31337";
+                txHash: `0x${string}`;
+                createdAt: string;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/platforms/getPlatform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/platforms/getPlatform/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;QAEjF"}

package/dist/src/staking/platforms/getPlatform/index.js

@@ -0,0 +1,4 @@
+import { createGetPlatformV0App } from "./v0/getPlatform.js";
+export function createGetPlatformApp(factory, tag) {
+    return factory.createApp().get("/v0", ...createGetPlatformV0App(factory, tag));
+}

package/dist/src/staking/platforms/getPlatform/v0/getPlatform.d.ts

@@ -0,0 +1,52 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITag } from "../../../../common/tag.js";
+export declare function createGetPlatformV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            address: `0x${string}`;
+            chainId: "11155111" | "31337";
+        };
+    };
+    out: {
+        query: {
+            address: `0x${string}`;
+            chainId: "11155111" | "31337";
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            address: `0x${string}`;
+            chainId: "11155111" | "31337";
+        };
+    };
+    out: {
+        query: {
+            address: `0x${string}`;
+            chainId: "11155111" | "31337";
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}, 200, "json">>>];
+//# sourceMappingURL=getPlatform.d.ts.map

package/dist/src/staking/platforms/getPlatform/v0/getPlatform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPlatform.d.ts","sourceRoot":"","sources":["../../../../../../src/staking/platforms/getPlatform/v0/getPlatform.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAK3B,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAIjD,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA8DnF"}

package/dist/src/staking/platforms/getPlatform/v0/getPlatform.js

@@ -0,0 +1,58 @@
+import { and, eq } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { indexerClient } from "../../../../common/indexer/index.js";
+import { z } from "../../../../common/zod.js";
+import { indexerSchemas } from "../../../../common/indexer/schemas.js";
+import { ErrorSchema, PlatformContractAddress, StakingChainId } from "../../../../common/index.js";
+import { PlatformNotFoundError } from "../../common/platformNotFound.js";
+import { PlatformSchema, mapToPlatform } from "../../common/platform.js";
+export function createGetPlatformV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Platform",
+        description: "Retrieve details of a specified platform",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Platform details",
+                content: {
+                    "application/json": {
+                        schema: resolver(PlatformSchema),
+                    },
+                },
+            },
+            404: {
+                description: "No platform found",
+                content: {
+                    "application/json": {
+                        schema: resolver(ErrorSchema),
+                    },
+                },
+            },
+        },
+    }), validator("query", z.object({
+        chainId: StakingChainId.openapi({
+            param: {
+                name: "chainId",
+                in: "query",
+            },
+        }),
+        address: PlatformContractAddress.openapi({
+            param: {
+                name: "address",
+                in: "query",
+            },
+        }),
+    })), async (c) => {
+        const { chainId, address } = c.req.valid("query");
+        const [platform] = await indexerClient.db
+            .select()
+            .from(indexerSchemas.diamonds)
+            .limit(1)
+            .where(and(eq(indexerSchemas.diamonds.chainId, Number(chainId)), eq(indexerSchemas.diamonds.contractAddress, address)));
+        if (!platform) {
+            throw new PlatformNotFoundError(chainId, address);
+        }
+        return c.json(mapToPlatform(platform), 200);
+    });
+}

package/dist/src/staking/platforms/index.d.ts

@@ -0,0 +1,52 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createPlatformsApp<E extends Env>(factory: Factory<E>): import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/v0": {
+        $get: {
+            input: {
+                query: {
+                    address: `0x${string}`;
+                    chainId: "11155111" | "31337";
+                };
+            };
+            output: {
+                chainId: "11155111" | "31337";
+                txHash: `0x${string}`;
+                createdAt: string;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/get"> | import("hono/types").MergeSchemaPath<{
+    "/v0": {
+        $post: {
+            input: {
+                json: {
+                    filter: {
+                        chainId?: "11155111" | "31337" | undefined;
+                        owner?: `0x${string}` | undefined;
+                    };
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                };
+            };
+            output: {
+                chainId: "11155111" | "31337";
+                txHash: `0x${string}`;
+                createdAt: string;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string;
+            }[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/search">, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/platforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/platforms/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAMpE"}

package/dist/src/staking/platforms/index.js

@@ -0,0 +1,10 @@
+import { createGetPlatformApp } from "./getPlatform/index.js";
+import { createSearchPlatformsApp } from "./searchPlatforms/index.js";
+import { createTag } from "../../common/tag.js";
+export function createPlatformsApp(factory) {
+    const tag = createTag("Platforms");
+    return factory
+        .createApp()
+        .route("/get", createGetPlatformApp(factory, tag))
+        .route("/search", createSearchPlatformsApp(factory, tag));
+}

package/dist/src/staking/platforms/searchPlatforms/index.d.ts

@@ -0,0 +1,32 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../common/tag.js";
+export declare function createSearchPlatformsApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
+    "/v0": {
+        $post: {
+            input: {
+                json: {
+                    filter: {
+                        chainId?: "11155111" | "31337" | undefined;
+                        owner?: `0x${string}` | undefined;
+                    };
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                };
+            };
+            output: {
+                chainId: "11155111" | "31337";
+                txHash: `0x${string}`;
+                createdAt: string;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string;
+            }[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/platforms/searchPlatforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/platforms/searchPlatforms/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;QAErF"}

package/dist/src/staking/platforms/searchPlatforms/index.js

@@ -0,0 +1,4 @@
+import { createSearchPlatformsV0App } from "./v0/searchPlatforms.js";
+export function createSearchPlatformsApp(factory, tag) {
+    return factory.createApp().post("/v0", ...createSearchPlatformsV0App(factory, tag));
+}