@evergonlabs/tmi-protocol-api 0.1.0

package/dist/staking/roles/searchRoles/v0/searchRoles.d.ts

@@ -0,0 +1,63 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../../common/tag.js";
+export declare function createSearchRolesV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: string | number | bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: string | number | bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=searchRoles.d.ts.map

package/dist/staking/roles/searchRoles/v0/searchRoles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchRoles.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/searchRoles/v0/searchRoles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAQjD,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAoDnF"}

package/dist/staking/roles/searchRoles/v0/searchRoles.js

@@ -0,0 +1,56 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
+import { and, eq } from "@ponder/client";
+import { z } from "../../../../common/zod.js";
+import { indexerClient } from "../../../../common/indexer/index.js";
+import { indexerSchemas } from "../../../../common/indexer/schemas.js";
+import { PageSchema } from "../../../../common/models/page.js";
+import { AddressSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../../../common/index.js";
+import { RoleAssignmentSchema } from "../../common/roleAssignment.js";
+export function createSearchRolesV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search roles",
+        description: "Search roles by users, platforms and pools",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns list of assignments within specified platforms and pools",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(RoleAssignmentSchema)),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        page: PageSchema,
+        filter: z.object({
+            chainId: StakingChainId.optional(),
+            owner: AddressSchema.optional(),
+            platform: PlatformContractAddress.optional(),
+            poolId: PoolIdSchema.optional(),
+        }),
+    })), async (c) => {
+        const { page, filter } = c.req.valid("json");
+        const result = await indexerClient.db
+            .select()
+            .from(indexerSchemas.roles)
+            .limit(page.limit)
+            .offset(page.skip)
+            .orderBy(indexerSchemas.roles.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.roles.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.roles.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.roles.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number" ? eq(indexerSchemas.roles.campaignId, BigInt(filter.poolId)) : undefined));
+        return c.json(result.map((x) => toRoleAssignment(x)), 200);
+    });
+}
+function toRoleAssignment(raw) {
+    return {
+        chainId: StakingChainId.parse(raw.chainId),
+        platform: raw.diamondAddress,
+        owner: raw.walletAddress,
+        roleId: raw.roleId,
+        poolId: raw.campaignId ? PoolIdSchema.parse(raw.campaignId) : undefined,
+        createdAt: unixToDate(raw.createdAt).toISOString(),
+        updatedAt: unixToDate(raw.updatedAt).toISOString(),
+    };
+}

package/dist/staking/stakes/common/stake.d.ts

@@ -0,0 +1,44 @@
+import { indexerSchemas } from "../../../common/indexer/schemas.js";
+import { z } from "../../../common/zod.js";
+export declare const StakeSchema: z.ZodObject<{
+    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    poolId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>>;
+    owner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    stakeId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    activePackets: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    rewardsClaimed: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    isActive: z.ZodBoolean;
+    unlockTimestamp: z.ZodString;
+    startTimestamp: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    createdAt: string;
+    updatedAt: string;
+    stakeId: bigint;
+    activePackets: bigint;
+    rewardsClaimed: bigint;
+    isActive: boolean;
+    unlockTimestamp: string;
+    startTimestamp: string;
+    owner: `0x${string}`;
+    poolId?: bigint | undefined;
+}, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    createdAt: string;
+    updatedAt: string;
+    stakeId: string | number | bigint;
+    activePackets: string | number | bigint;
+    rewardsClaimed: string | number | bigint;
+    isActive: boolean;
+    unlockTimestamp: string;
+    startTimestamp: string;
+    owner: `0x${string}`;
+    poolId?: string | number | bigint | undefined;
+}>;
+export declare function mapToStake(raw: typeof indexerSchemas.stakes.$inferSelect): z.output<typeof StakeSchema>;
+//# sourceMappingURL=stake.d.ts.map

package/dist/staking/stakes/common/stake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stake.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAE3C,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBpB,CAAC;AAEL,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAevG"}

package/dist/staking/stakes/common/stake.js

@@ -0,0 +1,45 @@
+import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { AddressSchema, PlatformContractAddress, PoolIdSchema, StakeIdSchema, StakingChainId, } from "../../../common/index.js";
+import { ISOSchema } from "../../../common/models/date.js";
+import { z } from "../../../common/zod.js";
+export const StakeSchema = z
+    .object({
+    chainId: StakingChainId,
+    platform: PlatformContractAddress,
+    poolId: PoolIdSchema.optional().openapi({
+        description: "If empty or 0 then it's platform-wide",
+    }),
+    owner: AddressSchema.openapi({
+        description: "Address role assigned to",
+    }),
+    stakeId: StakeIdSchema,
+    activePackets: Int256Positive,
+    rewardsClaimed: Int256Positive,
+    isActive: z.boolean().openapi({
+        description: "Whether stake is active or withdrawn and closed",
+    }),
+    unlockTimestamp: ISOSchema,
+    startTimestamp: ISOSchema,
+    createdAt: ISOSchema,
+    updatedAt: ISOSchema,
+})
+    .openapi({
+    ref: "Stake",
+});
+export function mapToStake(raw) {
+    return {
+        chainId: StakingChainId.parse(raw.chainId),
+        platform: raw.diamondAddress,
+        owner: raw.walletAddress,
+        poolId: raw.poolId ? PoolIdSchema.parse(raw.poolId) : undefined,
+        stakeId: raw.stakeId,
+        startTimestamp: unixToDate(raw.startTimestamp).toISOString(),
+        unlockTimestamp: unixToDate(raw.unlockTimestamp).toISOString(),
+        rewardsClaimed: raw.rewardsClaimed,
+        activePackets: raw.activePackets,
+        isActive: raw.isActive,
+        createdAt: unixToDate(raw.createdAt).toISOString(),
+        updatedAt: unixToDate(raw.updatedAt).toISOString(),
+    };
+}

package/dist/staking/stakes/common/stakeEvent.d.ts

@@ -0,0 +1,30 @@
+import { z } from "../../../common/zod.js";
+export declare const StakeEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    poolId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>>;
+    owner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    stakeId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    createdAt: z.ZodString;
+    txHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    id: string;
+    txHash: `0x${string}`;
+    createdAt: string;
+    stakeId: bigint;
+    owner: `0x${string}`;
+    poolId?: bigint | undefined;
+}, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    id: string;
+    txHash: `0x${string}`;
+    createdAt: string;
+    stakeId: string | number | bigint;
+    owner: `0x${string}`;
+    poolId?: string | number | bigint | undefined;
+}>;
+//# sourceMappingURL=stakeEvent.d.ts.map

package/dist/staking/stakes/common/stakeEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stakeEvent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAY3C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBzB,CAAC"}

package/dist/staking/stakes/common/stakeEvent.js

@@ -0,0 +1,24 @@
+import { ISOSchema } from "../../../common/models/date.js";
+import { z } from "../../../common/zod.js";
+import { AddressSchema, HashSchema, PlatformContractAddress, PoolIdSchema, StakeIdSchema, StakingChainId, } from "../../../common/index.js";
+// @todo add data field
+export const StakeEventSchema = z
+    .object({
+    id: z.string().openapi({
+        description: "Unique event id",
+    }),
+    chainId: StakingChainId,
+    platform: PlatformContractAddress,
+    poolId: PoolIdSchema.optional().openapi({
+        description: "If empty or 0 then it's platform-wide",
+    }),
+    owner: AddressSchema.openapi({
+        description: "Address role assigned to",
+    }),
+    stakeId: StakeIdSchema,
+    createdAt: ISOSchema,
+    txHash: HashSchema,
+})
+    .openapi({
+    ref: "StakeEvent",
+});

package/dist/staking/stakes/common/stakeNotFound.d.ts

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

package/dist/staking/stakes/common/stakeNotFound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakeNotFound.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stakeNotFound.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,qBAAa,kBAAmB,SAAQ,WAAW,CAAC;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;gBACY,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM;CAUhE"}

package/dist/staking/stakes/common/stakeNotFound.js

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

package/dist/staking/stakes/getStake/index.d.ts

@@ -0,0 +1,20 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../common/tag.js";
+export declare function createGetStakesApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
+    "/v0": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    stakeId: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/staking/stakes/getStake/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/getStake/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;QAE/E"}

package/dist/staking/stakes/getStake/index.js

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

package/dist/staking/stakes/getStake/v0/getStake.d.ts

@@ -0,0 +1,35 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITag } from "../../../../common/tag.js";
+export declare function createGetStakeV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            platform: string | string[];
+            stakeId: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            platform: `0x${string}`;
+            stakeId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            platform: string | string[];
+            stakeId: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            platform: `0x${string}`;
+            stakeId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=getStake.d.ts.map

package/dist/staking/stakes/getStake/v0/getStake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStake.d.ts","sourceRoot":"","sources":["../../../../../src/staking/stakes/getStake/v0/getStake.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,mBAAmB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAqEhF"}

package/dist/staking/stakes/getStake/v0/getStake.js

@@ -0,0 +1,64 @@
+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, StakeIdSchema, StakingChainId } from "../../../../common/index.js";
+import { mapToStake, StakeSchema } from "../../common/stake.js";
+import { StakeNotFoundError } from "../../common/stakeNotFound.js";
+export function createGetStakeV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Stake",
+        description: "Retrieve details of a specified stake",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Stake details",
+                content: {
+                    "application/json": {
+                        schema: resolver(StakeSchema),
+                    },
+                },
+            },
+            404: {
+                description: "No stake found",
+                content: {
+                    "application/json": {
+                        schema: resolver(ErrorSchema),
+                    },
+                },
+            },
+        },
+    }), validator("query", z.object({
+        chainId: StakingChainId.openapi({
+            param: {
+                name: "chainId",
+                in: "query",
+            },
+        }),
+        platform: PlatformContractAddress.openapi({
+            param: {
+                name: "platform",
+                in: "query",
+            },
+        }),
+        stakeId: StakeIdSchema.openapi({
+            param: {
+                name: "stakeId",
+                in: "query",
+            },
+        }),
+    })), async (c) => {
+        const { chainId, platform, stakeId } = c.req.valid("query");
+        const [stake] = await indexerClient.db
+            .select()
+            .from(indexerSchemas.stakes)
+            .limit(1)
+            .where(and(eq(indexerSchemas.stakes.chainId, Number(chainId)), eq(indexerSchemas.stakes.diamondAddress, platform), eq(indexerSchemas.stakes.stakeId, stakeId)));
+        if (!stake) {
+            throw new StakeNotFoundError(chainId, platform, stakeId.toString());
+        }
+        return c.json(mapToStake(stake), 200);
+    });
+}

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

@@ -0,0 +1,63 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createStakesApp<E extends Env>(factory: Factory<E>): import("hono/hono-base").HonoBase<E, 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">, "/">;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,wBAAgB,eAAe,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAOjE"}

package/dist/staking/stakes/index.js

@@ -0,0 +1,12 @@
+import { createSearchStakesApp } from "./searchStakes/index.js";
+import { createSearchStakeEventsApp } from "./searchStakeEvents/index.js";
+import { createGetStakesApp } from "./getStake/index.js";
+import { createTag } from "../../common/tag.js";
+export function createStakesApp(factory) {
+    const tag = createTag("Stakes");
+    return factory
+        .createApp()
+        .route("/searchStakes", createSearchStakesApp(factory, tag))
+        .route("/searchStakeEvents", createSearchStakeEventsApp(factory, tag))
+        .route("/getStake", createGetStakesApp(factory, tag));
+}

package/dist/staking/stakes/searchStakeEvents/index.d.ts

@@ -0,0 +1,27 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../common/tag.js";
+export declare function createSearchStakeEventsApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
+    "/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;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/staking/stakes/searchStakeEvents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/searchStakeEvents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAE3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;QAEvF"}

package/dist/staking/stakes/searchStakeEvents/index.js

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

package/dist/staking/stakes/searchStakeEvents/v0/searchStakeEvents.d.ts

@@ -0,0 +1,63 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../../common/tag.js";
+export declare function createSearchStakeEventsV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: string | number | bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: string | number | bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+                poolId?: bigint | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=searchStakeEvents.d.ts.map

package/dist/staking/stakes/searchStakeEvents/v0/searchStakeEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchStakeEvents.d.ts","sourceRoot":"","sources":["../../../../../src/staking/stakes/searchStakeEvents/v0/searchStakeEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAQjD,wBAAgB,4BAA4B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAsDzF"}