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

package/dist/stakingTemplates/templates/rwa/index.d.ts

@@ -3,8 +3,8 @@ export declare const RwaTemplateController: import("../../../common/controller.j
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -12,7 +12,7 @@ export declare const RwaTemplateController: import("../../../common/controller.j
                 admin: `0x${string}`;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getPlatformDeployEvent"> | import("hono/types").MergeSchemaPath<{
@@ -20,8 +20,8 @@ export declare const RwaTemplateController: import("../../../common/controller.j
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -42,8 +42,8 @@ export declare const RwaTemplateController: import("../../../common/controller.j
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -52,7 +52,7 @@ export declare const RwaTemplateController: import("../../../common/controller.j
                 rewardAssetHandler: `0x${string}`;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getCreatePoolEvent"> | import("hono/types").MergeSchemaPath<{
@@ -214,7 +214,7 @@ export declare const RwaTemplateController: import("../../../common/controller.j
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "31337" | "11155111" | "84532";
                     erc721: {
                         symbol: string;
                         name: string;

package/dist/stakingTemplates/templates/rwa/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAEhC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAEhC,CAAC"}

package/dist/stakingTemplates/templates/rwa/index.js

@@ -1,5 +1,5 @@
-import { createController } from "../../../common/controller.js";
 import { RwaTemplateV0 } from "./v0/index.js";
+import { createController } from "../../../common/controller.js";
 export const RwaTemplateController = createController({
     build: (factory) => factory.createApp().route("/v0", RwaTemplateV0.build(factory)),
 });

package/dist/stakingTemplates/templates/rwa/v0/createPlatform.d.ts

@@ -3,7 +3,7 @@ export declare const CreateRwaPlatformV0: import("../../../../common/controller.
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "31337" | "11155111" | "84532";
                     erc721: {
                         symbol: string;
                         name: string;

package/dist/stakingTemplates/templates/rwa/v0/createPlatform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createPlatform.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/createPlatform.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwD9B,CAAC"}
+{"version":3,"file":"createPlatform.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/createPlatform.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwD9B,CAAC"}

package/dist/stakingTemplates/templates/rwa/v0/createPlatform.js

@@ -1,12 +1,12 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { createPlatform, FacetOptionEnum } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { rwa } from "../common.js";
 import { createController } from "../../../../common/controller.js";
 import { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../../common/index.js";
 import { Erc721Schema } from "../../../../common/models/erc721.js";
-import { rwa } from "../common.js";
 export const CreateRwaPlatformV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create platform",

package/dist/stakingTemplates/templates/rwa/v0/createPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/createPool.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2E1B,CAAC"}
+{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/createPool.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2E1B,CAAC"}

package/dist/stakingTemplates/templates/rwa/v0/createPool.js

@@ -1,16 +1,16 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { createPool, FacetOptionEnum, FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { rwa } from "../common.js";
 import { createController } from "../../../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../../../common/index.js";
 import { PlatformContractAddress } from "../../../../common/models/platform.js";
-import { AmountHardCapSchema } from "../../common/amount.js";
-import { Erc20InputSchema } from "../../common/erc20Input.js";
-import { Erc20RewardSchema } from "../../common/erc20Reward.js";
-import { RewardDistributionComplexSchema } from "../../common/rewardDistribution.js";
-import { StartTimeSchema } from "../../common/time.js";
-import { rwa } from "../common.js";
+import { AmountHardCapSchema } from "../../../../stakingTemplates/templates/common/amount.js";
+import { Erc20InputSchema } from "../../../../stakingTemplates/templates/common/erc20Input.js";
+import { Erc20RewardSchema } from "../../../../stakingTemplates/templates/common/erc20Reward.js";
+import { RewardDistributionComplexSchema } from "../../../../stakingTemplates/templates/common/rewardDistribution.js";
+import { StartTimeSchema } from "../../../../stakingTemplates/templates/common/time.js";
 export const CreateRwaPoolV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create pool",

package/dist/stakingTemplates/templates/rwa/v0/distributeRewards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distributeRewards.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/distributeRewards.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;aA0CjC,CAAC"}
+{"version":3,"file":"distributeRewards.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/distributeRewards.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;aA0CjC,CAAC"}

package/dist/stakingTemplates/templates/rwa/v0/distributeRewards.js

@@ -1,12 +1,12 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { distributeRewards } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { rwa } from "../common.js";
 import { createController } from "../../../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { Int256BigInt } from "../../../../common/int256.js";
 import { PlatformContractAddress, PoolIdSchema } from "../../../../common/models/platform.js";
-import { rwa } from "../common.js";
 export const DistributeRewardsRwaV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Distribute rewards",
@@ -25,7 +25,7 @@ export const DistributeRewardsRwaV0 = createController({
     }), validator("json", z.object({
         platform: PlatformContractAddress,
         poolId: PoolIdSchema,
-        amount: Int256BigInt(z.bigint().positive()).openapi({
+        amount: Int256Json.openapi({
             description: "Number of Reward Packets to distribute to pool stakers.",
         }),
     })), async (c) => {

package/dist/stakingTemplates/templates/rwa/v0/index.d.ts

@@ -3,8 +3,8 @@ export declare const RwaTemplateV0: import("../../../../common/controller.js").I
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -12,7 +12,7 @@ export declare const RwaTemplateV0: import("../../../../common/controller.js").I
                 admin: `0x${string}`;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getPlatformDeployEvent"> | import("hono/types").MergeSchemaPath<{
@@ -20,8 +20,8 @@ export declare const RwaTemplateV0: import("../../../../common/controller.js").I
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -42,8 +42,8 @@ export declare const RwaTemplateV0: import("../../../../common/controller.js").I
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -52,7 +52,7 @@ export declare const RwaTemplateV0: import("../../../../common/controller.js").I
                 rewardAssetHandler: `0x${string}`;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getCreatePoolEvent"> | import("hono/types").MergeSchemaPath<{
@@ -214,7 +214,7 @@ export declare const RwaTemplateV0: import("../../../../common/controller.js").I
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "31337" | "11155111" | "84532";
                     erc721: {
                         symbol: string;
                         name: string;

package/dist/stakingTemplates/templates/rwa/v0/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAexB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAexB,CAAC"}

package/dist/stakingTemplates/templates/rwa/v0/index.js

@@ -1,16 +1,16 @@
-import { createController } from "../../../../common/controller.js";
-import { createGetCreatePoolEventController } from "../../common/getCreatePoolEvent.js";
-import { createGetPlatformDeployEventController } from "../../common/getPlatformDeployEvent.js";
-import { createGetRewardController } from "../../common/getReward.js";
-import { createGetStakeEventController } from "../../common/getStakeEvent.js";
-import { createPartialUnstakeController } from "../../common/partialUnstake.js";
-import { createUnstakeController } from "../../common/unstake.js";
 import { rwa } from "../common.js";
 import { CreateRwaPlatformV0 } from "./createPlatform.js";
 import { CreateRwaPoolV0 } from "./createPool.js";
 import { DistributeRewardsRwaV0 } from "./distributeRewards.js";
 import { RestakeRwaV0 } from "./restake.js";
 import { StakeRwaV0 } from "./stake.js";
+import { createController } from "../../../../common/controller.js";
+import { createGetCreatePoolEventController } from "../../../../stakingTemplates/templates/common/getCreatePoolEvent.js";
+import { createGetPlatformDeployEventController } from "../../../../stakingTemplates/templates/common/getPlatformDeployEvent.js";
+import { createGetRewardController } from "../../../../stakingTemplates/templates/common/getReward.js";
+import { createGetStakeEventController } from "../../../../stakingTemplates/templates/common/getStakeEvent.js";
+import { createPartialUnstakeController } from "../../../../stakingTemplates/templates/common/partialUnstake.js";
+import { createUnstakeController } from "../../../../stakingTemplates/templates/common/unstake.js";
 export const RwaTemplateV0 = createController({
     build: (factory) => factory
         .createApp()

package/dist/stakingTemplates/templates/rwa/v0/restake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restake.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/restake.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;aAyCvB,CAAC"}
+{"version":3,"file":"restake.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/restake.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;aAyCvB,CAAC"}

package/dist/stakingTemplates/templates/rwa/v0/restake.js

@@ -1,11 +1,11 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { stake } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { rwa } from "../common.js";
 import { createController } from "../../../../common/controller.js";
 import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { Int256BigInt } from "../../../../common/int256.js";
-import { rwa } from "../common.js";
 export const RestakeRwaV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Restake",
@@ -24,7 +24,7 @@ export const RestakeRwaV0 = createController({
     }), validator("json", z.object({
         platform: PlatformContractAddress,
         poolId: PoolIdSchema,
-        amount: Int256BigInt(z.bigint().positive()).openapi({
+        amount: Int256Json.openapi({
             description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
         }),
     })), async (c) => {

package/dist/stakingTemplates/templates/rwa/v0/stake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/stake.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;aA6CrB,CAAC"}
+{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/rwa/v0/stake.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;aA6CrB,CAAC"}

package/dist/stakingTemplates/templates/rwa/v0/stake.js

@@ -1,12 +1,12 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { stake } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { rwa } from "../common.js";
 import { createController } from "../../../../common/controller.js";
 import { PlatformContractAddress, PoolIdSchema, TransactionSchema } from "../../../../common/index.js";
 import { toTransaction } from "../../../../common/index.js";
-import { Int256BigInt } from "../../../../common/int256.js";
-import { rwa } from "../common.js";
 export const StakeRwaV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Stake",
@@ -25,7 +25,7 @@ export const StakeRwaV0 = createController({
     }), validator("json", z.object({
         platform: PlatformContractAddress,
         poolId: PoolIdSchema,
-        amount: Int256BigInt(z.bigint().positive()).openapi({
+        amount: Int256Json.openapi({
             description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
         }),
         // lockPeriod: z.string().pipe(z.coerce.number().int()).openapi({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evergonlabs/tmi-protocol-api",
-  "version": "0.11.0-rc.0",
+  "version": "0.11.0-rc.2",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -13,6 +13,24 @@
       "import": "./dist/app.js",
       "types": "./dist/app.d.ts",
       "default": "./dist/app.cjs"
+    },
+    "./schema": {
+      "import": "./dist/schemas.js",
+      "types": "./dist/schemas.d.ts"
+    },
+    "./next/client": {
+      "import": "./dist/next/client.js",
+      "types": "./dist/next/client.d.ts",
+      "default": "./dist/next/client.cjs"
+    },
+    "./next/app": {
+      "import": "./dist/next/app.js",
+      "types": "./dist/next/app.d.ts",
+      "default": "./dist/next/app.cjs"
+    },
+    "./next/schema": {
+      "import": "./dist/next/schemas.js",
+      "types": "./dist/next/schemas.d.ts"
     }
   },
   "files": [
@@ -20,9 +38,9 @@
   ],
   "dependencies": {
     "@evergonlabs/tmi-contracts-fractions-sdk": "1.2.3",
-    "@evergonlabs/tmi-evm-contracts": "0.6.7",
+    "@evergonlabs/tmi-evm-contracts": "0.8.0-rc.0",
     "@evergonlabs/tmi-factories-sdk": "0.3.1",
-    "@evergonlabs/tmi-utils": "0.6.0",
+    "@evergonlabs/tmi-utils": "0.8.0-rc.0",
     "@hono/node-server": "^1.19.9",
     "@hono/standard-validator": "^0.2.2",
     "@hono/swagger-ui": "^0.5.3",
@@ -39,17 +57,17 @@
     "viem": "2.46.2",
     "zod": "^4.3.6",
     "zod-openapi": "^5.4.6",
-    "@evergonlabs/tmi-protocol-contracts": "0.11.0-rc.0",
-    "@evergonlabs/tmi-protocol-fractions-sdk": "0.11.0-rc.0",
-    "@evergonlabs/tmi-protocol-indexer": "0.11.0-rc.0",
-    "@evergonlabs/tmi-protocol-shared": "0.11.0-rc.0",
-    "@evergonlabs/tmi-protocol-staking-sdk": "0.11.0-rc.0",
-    "@evergonlabs/tmi-protocol-types": "0.11.0-rc.0",
-    "@evergonlabs/tmi-protocol-utils": "0.11.0-rc.0"
+    "@evergonlabs/tmi-protocol-contracts": "0.11.0-rc.2",
+    "@evergonlabs/tmi-protocol-fractions-sdk": "0.11.0-rc.2",
+    "@evergonlabs/tmi-protocol-indexer": "0.11.0-rc.2",
+    "@evergonlabs/tmi-protocol-shared": "0.11.0-rc.2",
+    "@evergonlabs/tmi-protocol-staking-sdk": "0.11.0-rc.2",
+    "@evergonlabs/tmi-protocol-types": "0.11.0-rc.2",
+    "@evergonlabs/tmi-protocol-utils": "0.11.0-rc.2"
   },
   "devDependencies": {
-    "@evergonlabs/tmi-eslint-config": "0.3.0",
-    "@evergonlabs/tmi-typescript-config": "0.2.1",
+    "@evergonlabs/tmi-eslint-config": "0.8.0-rc.0",
+    "@evergonlabs/tmi-typescript-config": "0.8.0-rc.0",
     "@topcli/prompts": "^2.1.0",
     "dotenv": "^17.2.2",
     "esbuild": "^0.25.0",
@@ -61,6 +79,7 @@
     "openapi-typescript": "^7.6.0",
     "rdme": "^10.0.0",
     "rimraf": "^6.0.1",
+    "tsc-alias": "^1.8.16",
     "tsx": "^4.19.2",
     "typescript": "5.7.3",
     "vitest": "^3.1.3",
@@ -75,7 +94,7 @@
   },
   "scripts": {
     "build": "run-s openapi:generate build:lib",
-    "build:lib": "tsc -p tsconfig.build.json",
+    "build:lib": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "check-types": "tsc --noEmit",
     "clean": "rimraf ./dist ./artifacts",
     "docs:upload": "pnpm run env -- pnpm run tsx:oa -- ./scripts/generateAndUpload/bin.ts",

package/dist/common/int256.d.ts

@@ -1,3 +0,0 @@
-import { z } from "zod";
-export declare function Int256BigInt(validator?: z.ZodBigInt): z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-//# sourceMappingURL=int256.d.ts.map

package/dist/common/int256.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"int256.d.ts","sourceRoot":"","sources":["../../src/common/int256.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,SAAS,yHASnD"}

package/dist/common/int256.js

@@ -1,12 +0,0 @@
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
-export function Int256BigInt(validator) {
-    return Int256Json.transform((x) => {
-        const val = BigInt(x);
-        if (validator)
-            validator.parse(val);
-        return val;
-    }).openapi({
-        example: "42",
-        type: "integer",
-    });
-}

package/dist/common/models/base/chainId.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-export declare const StakingChainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532>, z.ZodLiteral<11155111 | 31337 | 84532>, ...z.ZodLiteral<11155111 | 31337 | 84532>[]]>>;
-export declare const FractionsChainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>[]]>>;
-export declare const NextFractionsChainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 84532 | 72080>[]]>>;
-export declare const PolymorphicChainIds: (1 | 11155111 | 31337 | 84532 | 72080)[];
-export declare const PolymorphicChainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodIntersection<z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>[]]>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532>, z.ZodLiteral<11155111 | 31337 | 84532>, ...z.ZodLiteral<11155111 | 31337 | 84532>[]]>>>;
-export type IPolymorphicChainId = (typeof PolymorphicChainIds)[number];
-//# sourceMappingURL=chainId.d.ts.map

package/dist/common/models/base/chainId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chainId.d.ts","sourceRoot":"","sources":["../../../../src/common/models/base/chainId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,cAAc,wLAAoD,CAAC;AAEhF,eAAO,MAAM,gBAAgB,4NAAsD,CAAC;AAEpF,eAAO,MAAM,oBAAoB,gNAA0D,CAAC;AAE5F,eAAO,MAAM,mBAAmB,0CAAyE,CAAC;AAC1G,eAAO,MAAM,kBAAkB,0XAG9B,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/common/models/base/chainId.js

@@ -1,11 +0,0 @@
-import { z } from "zod";
-import { FractionsChains } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { FractionsChains as NextFractionsChains } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { StakingChains } from "@evergonlabs/tmi-protocol-staking-sdk";
-// This preprocess is for back compatibility
-const coerceChainId = (v) => (typeof v === "string" ? Number(v) : v);
-export const StakingChainId = z.preprocess(coerceChainId, StakingChains.Schema);
-export const FractionsChainId = z.preprocess(coerceChainId, FractionsChains.Schema);
-export const NextFractionsChainId = z.preprocess(coerceChainId, NextFractionsChains.Schema);
-export const PolymorphicChainIds = [...new Set([...FractionsChains.chainIds, ...StakingChains.chainIds])];
-export const PolymorphicChainId = z.preprocess(coerceChainId, z.intersection(FractionsChains.Schema, StakingChains.Schema));

package/dist/common/models/base/date.d.ts

@@ -1,6 +0,0 @@
-import { z } from "zod";
-export declare const ISOJsonBase: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
-export type IISOJson = z.output<typeof ISOJsonBase>;
-export declare function ISODate(validator?: z.ZodDate): z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
-export declare function toISOJson(date: Date): IISOJson;
-//# sourceMappingURL=date.d.ts.map

package/dist/common/models/base/date.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../src/common/models/base/date.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW,+CAAqC,CAAC;AAE9D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AAEpD,wBAAgB,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,OAAO,iHAM5C;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,QAAQ,CAE9C"}

package/dist/common/models/base/date.js

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export const ISOJsonBase = z.string().datetime().brand("ISO");
-export function ISODate(validator) {
-    return ISOJsonBase.transform((x) => {
-        const val = new Date(x);
-        if (validator)
-            validator.parse(val);
-        return val;
-    });
-}
-export function toISOJson(date) {
-    return date.toISOString();
-}

package/dist/common/models/base/deployTransaction.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-export declare const DeployTransactionSchema: z.ZodObject<{
-    bytecode: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    abi: z.ZodArray<z.ZodAny>;
-    args: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-}, z.core.$strip>;
-export type IDeployTransactionSchema = z.output<typeof DeployTransactionSchema>;
-//# sourceMappingURL=deployTransaction.d.ts.map

package/dist/common/models/base/deployTransaction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployTransaction.d.ts","sourceRoot":"","sources":["../../../../src/common/models/base/deployTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/common/models/base/deployTransaction.js

@@ -1,7 +0,0 @@
-import { z } from "zod";
-import { AbiSchema, HexStringSchema } from "./viem.js";
-export const DeployTransactionSchema = z.object({
-    bytecode: HexStringSchema,
-    abi: AbiSchema,
-    args: z.array(z.any()).optional(),
-});

package/dist/common/models/base/page.d.ts

@@ -1,7 +0,0 @@
-import { z } from "zod";
-export declare const PageSchema: z.ZodObject<{
-    skip: z.ZodNumber;
-    limit: z.ZodNumber;
-}, z.core.$strip>;
-export type IPageSchema = z.output<typeof PageSchema>;
-//# sourceMappingURL=page.d.ts.map

package/dist/common/models/base/page.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../src/common/models/base/page.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;iBAGrB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/common/models/base/page.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-export const PageSchema = z.object({
-    skip: z.number().min(0),
-    limit: z.number().min(0).max(50),
-});

package/dist/common/models/base/transaction.d.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-export declare const TransactionSchema: z.ZodObject<{
-    data: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    details: z.ZodObject<{
-        functionName: z.ZodString;
-        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        abi: z.ZodArray<z.ZodAny>;
-        args: z.ZodArray<z.ZodAny>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ITransactionSchema = z.output<typeof TransactionSchema>;
-//# sourceMappingURL=transaction.d.ts.map

package/dist/common/models/base/transaction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../src/common/models/base/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;iBAS5B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/common/models/base/transaction.js

@@ -1,12 +0,0 @@
-import { z } from "zod";
-import { AbiSchema, AddressSchema, HexStringSchema } from "./viem.js";
-export const TransactionSchema = z.object({
-    data: HexStringSchema,
-    to: AddressSchema,
-    details: z.object({
-        functionName: z.string(),
-        address: AddressSchema,
-        abi: AbiSchema,
-        args: z.array(z.any()),
-    }),
-});

package/dist/common/models/base/viem.d.ts

@@ -1,6 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, HexStringSchema } from "@evergonlabs/tmi-utils/models";
-export { AddressSchema, HexStringSchema };
-export { HexStringSchema as HashSchema };
-export declare const AbiSchema: z.ZodArray<z.ZodAny>;
-//# sourceMappingURL=viem.d.ts.map

package/dist/common/models/base/viem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["../../../../src/common/models/base/viem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAE/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC;AAC1C,OAAO,EAAE,eAAe,IAAI,UAAU,EAAE,CAAC;AACzC,eAAO,MAAM,SAAS,sBAAmB,CAAC"}

package/dist/common/models/base/viem.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, HexStringSchema } from "@evergonlabs/tmi-utils/models";
-export { AddressSchema, HexStringSchema };
-export { HexStringSchema as HashSchema };
-export const AbiSchema = z.array(z.any());

package/dist/common/models/date.d.ts

@@ -1,2 +0,0 @@
-export declare const ISOJson: import("zod/v4/core").$ZodBranded<import("zod").ZodString, "ISO", "out">;
-//# sourceMappingURL=date.d.ts.map

package/dist/common/models/date.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/common/models/date.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,0EAElB,CAAC"}

package/dist/common/models/date.js

@@ -1,4 +0,0 @@
-import { ISOJsonBase } from "./base/date.js";
-export const ISOJson = ISOJsonBase.openapi({
-    description: "Date in ISO format",
-});

package/dist/common/models/percent.d.ts

@@ -1,3 +0,0 @@
-import { z } from "zod";
-export declare const PercentageSchema: z.ZodNumber;
-//# sourceMappingURL=percent.d.ts.map

package/dist/common/models/percent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"percent.d.ts","sourceRoot":"","sources":["../../../src/common/models/percent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,aAIiD,CAAC"}

package/dist/common/models/percent.js

@@ -1,6 +0,0 @@
-import { z } from "zod";
-export const PercentageSchema = z
-    .number()
-    .min(0)
-    .max(10000)
-    .openapi({ description: "Percentage in basis points, i.e. 10000bp = 100%" });

package/dist/common/models/saleId.d.ts

@@ -1,6 +0,0 @@
-import { z } from "zod";
-export declare const SaleIdSchema: z.ZodObject<{
-    market: 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>;
-//# sourceMappingURL=saleId.d.ts.map