@evergonlabs/tmi-protocol-api 0.1.0

package/dist/src/staking/roles/common/roleEvent.d.ts

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

package/dist/src/staking/roles/common/roleEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roleEvent.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/common/roleEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAU3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBxB,CAAC"}

package/dist/src/staking/roles/common/roleEvent.js

@@ -0,0 +1,23 @@
+import { z } from "../../../common/zod.js";
+import { RoleIdSchema } from "./role.js";
+import { AddressSchema, HashSchema, PlatformContractAddress, PoolIdSchema, StakingChainId, } from "../../../common/index.js";
+export const RoleEventSchema = z
+    .object({
+    id: z.string().openapi({
+        description: "Unique event id",
+    }),
+    roleId: RoleIdSchema,
+    chainId: StakingChainId,
+    platform: PlatformContractAddress,
+    txHash: HashSchema,
+    owner: AddressSchema,
+    poolId: PoolIdSchema.optional().openapi({
+        description: "If empty or 0 then it's platform-wide",
+    }),
+    isRevoked: z.boolean().openapi({
+        description: "Whether role is revoked or granted",
+    }),
+})
+    .openapi({
+    ref: "RoleEvent",
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/getRoles/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,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;QAE9E"}

package/dist/src/staking/roles/getRoles/index.js

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

package/dist/src/staking/roles/getRoles/v0/getRoles.d.ts

@@ -0,0 +1,29 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../../common/tag.js";
+export declare function createGetRolesV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Response & import("hono").TypedResponse<({
+    name: string;
+    value: `0x${string}`;
+} | {
+    name: string;
+    value: `0x${string}`;
+} | {
+    name: string;
+    value: `0x${string}`;
+} | {
+    name: string;
+    value: `0x${string}`;
+})[], 200, "json">>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {}, Response & import("hono").TypedResponse<({
+    name: string;
+    value: `0x${string}`;
+} | {
+    name: string;
+    value: `0x${string}`;
+} | {
+    name: string;
+    value: `0x${string}`;
+} | {
+    name: string;
+    value: `0x${string}`;
+})[], 200, "json">>];
+//# sourceMappingURL=getRoles.d.ts.map

package/dist/src/staking/roles/getRoles/v0/getRoles.d.ts.map

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

package/dist/src/staking/roles/getRoles/v0/getRoles.js

@@ -0,0 +1,41 @@
+import { describeRoute } from "hono-openapi";
+import { resolver } from "hono-openapi/zod";
+import { getStakingRole, StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { RoleSchema } from "../../common/role.js";
+import { z } from "../../../../common/zod.js";
+export function createGetRolesV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Roles",
+        description: "Retrieve all available (pre-defined) roles",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "List of available roles",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(RoleSchema)),
+                    },
+                },
+            },
+        },
+    }), (c) => c.json(allRoles, 200));
+}
+const roleByRole = {
+    [StakingRole.Admin]: {
+        name: "Admin",
+        value: getStakingRole(StakingRole.Admin),
+    },
+    [StakingRole.Creator]: {
+        name: "Creator",
+        value: getStakingRole(StakingRole.Creator),
+    },
+    [StakingRole.Open]: {
+        name: "Open",
+        value: getStakingRole(StakingRole.Open),
+    },
+    [StakingRole.Staker]: {
+        name: "Staker",
+        value: getStakingRole(StakingRole.Staker),
+    },
+};
+const allRoles = Object.values(roleByRole);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/grantRole/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,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;QAE/E"}

package/dist/src/staking/roles/grantRole/index.js

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

package/dist/src/staking/roles/grantRole/v0/grantRole.d.ts

@@ -0,0 +1,63 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { ITag } from "../../../../common/tag.js";
+export declare function createGrantRoleV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            addresses: `0x${string}`[];
+            role: `0x${string}` | StakingRole;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            addresses: `0x${string}`[];
+            role: `0x${string}` | StakingRole;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            addresses: `0x${string}`[];
+            role: `0x${string}` | StakingRole;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            addresses: `0x${string}`[];
+            role: `0x${string}` | StakingRole;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>];
+//# sourceMappingURL=grantRole.d.ts.map

package/dist/src/staking/roles/grantRole/v0/grantRole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../../../../src/staking/roles/grantRole/v0/grantRole.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAa,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAI/E,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAEjD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAwCjF"}

package/dist/src/staking/roles/grantRole/v0/grantRole.js

@@ -0,0 +1,40 @@
+import { resolver, validator } from "hono-openapi/zod";
+import { describeRoute } from "hono-openapi";
+import { grantRole, StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { PlatformContractAddress } from "../../../../common/models/platform.js";
+import { z } from "../../../../common/zod.js";
+export function createGrantRoleV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Grant Role",
+        description: "Generates transaction for granting specified role to user addreses within the platform",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns estimated gas or estimation error",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        platform: PlatformContractAddress,
+        addresses: z.array(AddressSchema).openapi({
+            description: "List of address you want assign role to",
+        }),
+        role: z.union([z.nativeEnum(StakingRole), HexStringSchema]).openapi({
+            description: "Id of a role assign to",
+            example: StakingRole.Staker,
+        }),
+    })), async (c) => {
+        const { platform, role, addresses } = c.req.valid("json");
+        const deployed = grantRole({
+            platform: platform,
+            role: role,
+            addresses: addresses,
+        });
+        return c.json(toTransaction(deployed), 200);
+    });
+}

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { createGrantRoleApp } from "./grantRole/index.js";
+import { createGetRolesApp } from "./getRoles/index.js";
+import { createSearchRolesApp } from "./searchRoles/index.js";
+import { createSearchRoleEventsApp } from "./searchRoleEvents/index.js";
+import { createTag } from "../../common/tag.js";
+export function createRolesApp(factory) {
+    const tag = createTag("Roles");
+    return factory
+        .createApp()
+        .route("/getRoles", createGetRolesApp(factory, tag))
+        .route("/grantRole", createGrantRoleApp(factory, tag))
+        .route("/searchRoles", createSearchRolesApp(factory, tag))
+        .route("/searchRoleEvents", createSearchRoleEventsApp(factory, tag));
+}

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

@@ -0,0 +1,27 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITag } from "../../../common/tag.js";
+export declare function createSearchRoleEventsApp<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/src/staking/roles/searchRoleEvents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/searchRoleEvents/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,yBAAyB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;QAEtF"}

package/dist/src/staking/roles/searchRoleEvents/index.js

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

package/dist/src/staking/roles/searchRoleEvents/v0/searchRoleEvents.d.ts

@@ -0,0 +1,63 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../../common/tag.js";
+export declare function createSearchRoleEventsV0App<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=searchRoleEvents.d.ts.map

package/dist/src/staking/roles/searchRoleEvents/v0/searchRoleEvents.d.ts.map

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

package/dist/src/staking/roles/searchRoleEvents/v0/searchRoleEvents.js

@@ -0,0 +1,58 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+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 createSearchRoleEventsV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search role events",
+        description: "Search role events by platform, user and kind",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns list of role events by some filter",
+                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.roleEvents)
+            .limit(page.limit)
+            .offset(page.skip)
+            .orderBy(indexerSchemas.roleEvents.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.roleEvents.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.roleEvents.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.roleEvents.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number"
+            ? eq(indexerSchemas.roleEvents.campaignId, BigInt(filter.poolId))
+            : undefined));
+        return c.json(result.map((x) => toRoleEvent(x)), 200);
+    });
+}
+function toRoleEvent(raw) {
+    return {
+        id: raw.id,
+        chainId: StakingChainId.parse(raw.chainId),
+        platform: raw.diamondAddress,
+        owner: raw.walletAddress,
+        roleId: raw.roleId,
+        poolId: raw.campaignId ? PoolIdSchema.parse(raw.campaignId) : undefined,
+        txHash: raw.txHash,
+        isRevoked: raw.isRevoked,
+    };
+}

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

@@ -0,0 +1,27 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITag } from "../../../common/tag.js";
+export declare function createSearchRolesApp<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/src/staking/roles/searchRoles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/searchRoles/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/roles/searchRoles/index.js

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