@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/staking-templates/templates/common/erc20Input.js

@@ -1,16 +1,14 @@
-import { z } from "../../../common/zod.js";
 import { AddressSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { z } from "zod";
 export const Erc20InputSchema = z
     .object({
     contract: AddressSchema.openapi({
         description: "An address of the ERC20 token encapsulated by the Input Packet.",
     }),
-    amountOfTokensPerPacket: z.string().pipe(z.coerce.bigint()).openapi({
+    amountOfTokensPerPacket: Int256BigInt().openapi({
         type: "string",
         description: "Amount of tokens per Packet (using Wei)",
     }),
 })
-    .openapi({
-    ref: "Erc20Input",
-    description: "Address and amount of tokens per Packet to be used as an Input for a Staking Pool",
-});
+    .openapi("Erc20Input", { description: "Address and amount of tokens per Packet to be used as an Input for a Staking Pool", });

package/dist/staking-templates/templates/common/erc20Reward.d.ts

@@ -1,12 +1,6 @@
-import { z } from "../../../common/zod.js";
+import { z } from "zod";
 export declare const Erc20RewardSchema: z.ZodObject<{
-    contract: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    amountOfTokensPerPacket: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-}, "strip", z.ZodTypeAny, {
-    contract: `0x${string}`;
-    amountOfTokensPerPacket: bigint;
-}, {
-    contract: `0x${string}`;
-    amountOfTokensPerPacket: string | number | bigint;
-}>;
+    contract: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amountOfTokensPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
 //# sourceMappingURL=erc20Reward.d.ts.map

package/dist/staking-templates/templates/common/erc20Reward.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"erc20Reward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/erc20Reward.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAI3C,eAAO,MAAM,iBAAiB;;;;;;;;;EAY1B,CAAC"}
+{"version":3,"file":"erc20Reward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/erc20Reward.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;iBASkG,CAAC"}

package/dist/staking-templates/templates/common/erc20Reward.js

@@ -1,16 +1,13 @@
-import { z } from "../../../common/zod.js";
 import { AddressSchema } from "../../../common/index.js";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { Int256BigInt } from "../../../common/int256.js";
+import { z } from "zod";
 export const Erc20RewardSchema = z
     .object({
     contract: AddressSchema.openapi({
         description: `An address of the ERC20 token encapsulated by the reward Packet.`,
     }),
-    amountOfTokensPerPacket: Int256Positive.openapi({
+    amountOfTokensPerPacket: Int256BigInt(z.bigint().positive()).openapi({
         description: `Amount of tokens per Packet \n\nIMPORTANT: should be parsed with each token's decimal precision (using wei values)`,
     }),
 })
-    .openapi({
-    ref: "Erc20Reward",
-    description: "Address and amount of tokens per Packet to be used as a Reward for a staking Pool",
-});
+    .openapi("Erc20Reward", { description: "Address and amount of tokens per Packet to be used as a Reward for a staking Pool", });

package/dist/staking-templates/templates/common/getCreatePoolEvent.d.ts

@@ -10,7 +10,7 @@ export declare function createGetCreatePoolEventRoute<E extends Env>(factory: Fa
     };
     out: {
         query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 11155111 | 31337 | 72080;
             hash: `0x${string}`;
         };
     };
@@ -23,7 +23,7 @@ export declare function createGetCreatePoolEventRoute<E extends Env>(factory: Fa
     };
     out: {
         query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 11155111 | 31337 | 72080;
             hash: `0x${string}`;
         };
     };

package/dist/staking-templates/templates/common/getCreatePoolEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getCreatePoolEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getCreatePoolEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAQvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;0EAoC1G"}
+{"version":3,"file":"getCreatePoolEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getCreatePoolEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;0EAoC1G"}

package/dist/staking-templates/templates/common/getCreatePoolEvent.js

@@ -1,11 +1,11 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
 import { parseAssetManagersDeployEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema } from "../../../common/index.js";
 import { getPublicClient } from "../../../common/blockchain.js";
 import { HttpError } from "../../../common/http-error.js";
-import { z } from "../../../common/zod.js";
+import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+import { z } from "zod";
 export function createGetCreatePoolEventRoute(factory, template) {
     return factory.createHandlers(describeRoute({
         summary: "Get Pool Create Event",

package/dist/staking-templates/templates/common/getPlatformDeployEvent.d.ts

@@ -13,7 +13,7 @@ export declare function createGetPlatformDeployEventRoute<E extends Env>(factory
     };
     out: {
         query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 11155111 | 31337 | 72080;
             hash: `0x${string}`;
         };
     };
@@ -29,7 +29,7 @@ export declare function createGetPlatformDeployEventRoute<E extends Env>(factory
     };
     out: {
         query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 11155111 | 31337 | 72080;
             hash: `0x${string}`;
         };
     };

package/dist/staking-templates/templates/common/getPlatformDeployEvent.js

@@ -1,11 +1,11 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { parseDeployDiamondEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
-import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+import { parseDeployDiamondEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { getPublicClient } from "../../../common/blockchain.js";
 import { HttpError } from "../../../common/http-error.js";
-import { z } from "../../../common/zod.js";
+import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+import { z } from "zod";
 export function createGetPlatformDeployEventRoute(factory, template) {
     return factory.createHandlers(describeRoute({
         summary: "Get Platform Deploy Event",

package/dist/staking-templates/templates/common/getReward.d.ts

@@ -1,56 +1,56 @@
-import { Factory } from "hono/factory";
 import { Env } from "hono";
+import { Factory } from "hono/factory";
 import { ITemplateHelper } from "./templates.js";
 export declare function createGetRewardRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         functionName: string;
+        address: `0x${string}`;
         abi: any[];
         args: any[];
     };
 }, 200, "json">>>, import("hono/types").H<Env, string, {
     in: {
         json: {
-            stakeId: string | number | bigint;
-            platform: `0x${string}`;
+            platform: string;
+            stakeId: string;
         };
     };
     out: {
         json: {
-            stakeId: bigint;
             platform: `0x${string}`;
+            stakeId: bigint;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         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: {
-            stakeId: string | number | bigint;
-            platform: `0x${string}`;
+            platform: string;
+            stakeId: string;
         };
     };
     out: {
         json: {
-            stakeId: bigint;
             platform: `0x${string}`;
+            stakeId: bigint;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         functionName: string;
+        address: `0x${string}`;
         abi: any[];
         args: any[];
     };

package/dist/staking-templates/templates/common/getReward.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getReward.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAM3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmCjG"}
+{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getReward.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmCjG"}

package/dist/staking-templates/templates/common/getReward.js

@@ -1,8 +1,8 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { z } from "../../../common/zod.js";
+import { resolver, validator } from "hono-openapi";
 import { getReward } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { z } from "zod";
 export function createGetRewardRoute(factory, template) {
     return factory.createHandlers(describeRoute({
         summary: "Get Reward",

package/dist/staking-templates/templates/common/getStakeEvent.d.ts

@@ -1,5 +1,5 @@
-import { Factory } from "hono/factory";
 import { Env } from "hono";
+import { Factory } from "hono/factory";
 import { ITemplateHelper } from "./templates.js";
 export declare function createStakeEventRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
     in: {
@@ -10,7 +10,7 @@ export declare function createStakeEventRoute<E extends Env>(factory: Factory<E>
     };
     out: {
         query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 11155111 | 31337 | 72080;
             hash: `0x${string}`;
         };
     };
@@ -23,7 +23,7 @@ export declare function createStakeEventRoute<E extends Env>(factory: Factory<E>
     };
     out: {
         query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            chainId: 1 | 11155111 | 31337 | 72080;
             hash: `0x${string}`;
         };
     };

package/dist/staking-templates/templates/common/getStakeEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getStakeEvent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAM3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;0EAwClG"}
+{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getStakeEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;0EAwClG"}

package/dist/staking-templates/templates/common/getStakeEvent.js

@@ -1,11 +1,11 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
 import { parseStakeEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema, StakeIdSchema } from "../../../common/index.js";
-import { z } from "../../../common/zod.js";
 import { getPublicClient } from "../../../common/blockchain.js";
 import { HttpError } from "../../../common/http-error.js";
-import { waitForTransactionReceipt } from "viem/actions";
+import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema, StakeIdSchema } from "../../../common/index.js";
+import { z } from "zod";
 export function createStakeEventRoute(factory, template) {
     return factory.createHandlers(describeRoute({
         summary: "Get Stake Event",

package/dist/staking-templates/templates/common/lock.d.ts

@@ -1,12 +1,6 @@
-import { z } from "../../../common/zod.js";
+import { z } from "zod";
 export declare const LockTwoBorderSchema: z.ZodObject<{
-    minAcceptedLockPeriod: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    maxAcceptedLockPeriod: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-}, "strip", z.ZodTypeAny, {
-    minAcceptedLockPeriod: bigint;
-    maxAcceptedLockPeriod: bigint;
-}, {
-    minAcceptedLockPeriod: string | number | bigint;
-    maxAcceptedLockPeriod: string | number | bigint;
-}>;
+    minAcceptedLockPeriod: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    maxAcceptedLockPeriod: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
 //# sourceMappingURL=lock.d.ts.map

package/dist/staking-templates/templates/common/lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,eAAO,MAAM,mBAAmB;;;;;;;;;EAiB5B,CAAC"}
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/lock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;iBAeL,CAAC"}

package/dist/staking-templates/templates/common/lock.js

@@ -1,20 +1,18 @@
-import { z } from "../../../common/zod.js";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { Int256BigInt } from "../../../common/int256.js";
+import { z } from "zod";
 export const LockTwoBorderSchema = z
     .object({
-    minAcceptedLockPeriod: Int256Positive.openapi({
+    minAcceptedLockPeriod: Int256BigInt(z.bigint().positive()).openapi({
         description: `The minimum required time duration (in seconds), that staked assets must 
       be locked when the positions are either created (stake) or increased (restake).
       \n\n
       Note: Must be less than or equal to maxAcceptedLockPeriod.`,
     }),
-    maxAcceptedLockPeriod: Int256Positive.openapi({
+    maxAcceptedLockPeriod: Int256BigInt(z.bigint().positive()).openapi({
         description: `The maximum allowed time duration (in seconds), that staked assets can be 
       locked when the positions are either created (stake) or increased (restake).
       \n\n
       Note: Must be greater than 0 (if no upper limit is required, use max int 256).`,
     }),
 })
-    .openapi({
-    ref: "LockTwoBorder",
-});
+    .openapi("LockTwoBorder");

package/dist/staking-templates/templates/common/lockMult.d.ts

@@ -1,3 +1,3 @@
-import { z } from "../../../common/zod.js";
-export declare const LockMultIntervalSchema: z.ZodArray<z.ZodTuple<[z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>, z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>], null>, "many">;
+import { z } from "zod";
+export declare const LockMultIntervalSchema: z.ZodArray<z.ZodTuple<[z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>, z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>], null>>;
 //# sourceMappingURL=lockMult.d.ts.map

package/dist/staking-templates/templates/common/lockMult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lockMult.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/lockMult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,eAAO,MAAM,sBAAsB,0MAYjC,CAAC"}
+{"version":3,"file":"lockMult.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/lockMult.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB,8QAWjC,CAAC"}

package/dist/staking-templates/templates/common/lockMult.js

@@ -1,7 +1,6 @@
-import { z } from "../../../common/zod.js";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
-export const LockMultIntervalSchema = z.array(z.tuple([Int256Positive, Int256Positive])).openapi({
-    ref: "LockMultInterval",
+import { Int256BigInt } from "../../../common/int256.js";
+import { z } from "zod";
+export const LockMultIntervalSchema = z.array(z.tuple([Int256BigInt(z.bigint().positive()), Int256BigInt(z.bigint().positive())])).openapi("LockMultInterval", {
     description: `An array of tuples where:
     
     1st element: A time duration (in seconds) defining lock duration thresholds for lock-based multipliers.

package/dist/staking-templates/templates/common/partialUnstake.d.ts

@@ -1,60 +1,60 @@
-import { Factory } from "hono/factory";
 import { Env } from "hono";
+import { Factory } from "hono/factory";
 import { ITemplateHelper } from "./templates.js";
 export declare function createPartialUnstakeRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         functionName: string;
+        address: `0x${string}`;
         abi: any[];
         args: any[];
     };
 }, 200, "json">>>, import("hono/types").H<Env, string, {
     in: {
         json: {
-            stakeId: string | number | bigint;
-            amount: string | number | bigint;
-            platform: `0x${string}`;
+            platform: string;
+            stakeId: string;
+            amount: string;
         };
     };
     out: {
         json: {
+            platform: `0x${string}`;
             stakeId: bigint;
             amount: bigint;
-            platform: `0x${string}`;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         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: {
-            stakeId: string | number | bigint;
-            amount: string | number | bigint;
-            platform: `0x${string}`;
+            platform: string;
+            stakeId: string;
+            amount: string;
         };
     };
     out: {
         json: {
+            platform: `0x${string}`;
             stakeId: bigint;
             amount: bigint;
-            platform: `0x${string}`;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         functionName: string;
+        address: `0x${string}`;
         abi: any[];
         args: any[];
     };

package/dist/staking-templates/templates/common/partialUnstake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"partialUnstake.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/partialUnstake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAO3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAuCtG"}
+{"version":3,"file":"partialUnstake.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/partialUnstake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAOvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAuCtG"}

package/dist/staking-templates/templates/common/partialUnstake.js

@@ -1,9 +1,9 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
 import { partialUnstake } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { z } from "../../../common/zod.js";
 import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { Int256BigInt } from "../../../common/int256.js";
+import { z } from "zod";
 export function createPartialUnstakeRoute(factory, template) {
     return factory.createHandlers(describeRoute({
         summary: "Partial Unstake",
@@ -22,7 +22,7 @@ export function createPartialUnstakeRoute(factory, template) {
     }), validator("json", z.object({
         platform: PlatformContractAddress,
         stakeId: StakeIdSchema,
-        amount: Int256Positive.openapi({
+        amount: Int256BigInt(z.bigint().positive()).openapi({
             description: `The number of input packets to withdraw from the position, thereby decreasing it.`,
         }),
     })), async (c) => {

package/dist/staking-templates/templates/common/rewardDistribution.d.ts

@@ -1,13 +1,7 @@
-import { z } from "../../../common/zod.js";
+import { z } from "zod";
 export declare const RewardDistributionComplexSchema: z.ZodObject<{
-    duration: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    distributor: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    duration: bigint;
-    distributor: `0x${string}`;
-}, {
-    duration: string | number | bigint;
-    distributor: `0x${string}`;
-}>;
-export declare const RewardRateSchema: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    duration: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    distributor: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const RewardRateSchema: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
 //# sourceMappingURL=rewardDistribution.d.ts.map

package/dist/staking-templates/templates/common/rewardDistribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewardDistribution.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/rewardDistribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAI3C,eAAO,MAAM,+BAA+B;;;;;;;;;EAYxC,CAAC;AAEL,eAAO,MAAM,gBAAgB,iFAE3B,CAAC"}
+{"version":3,"file":"rewardDistribution.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/rewardDistribution.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,+BAA+B;;;iBASgD,CAAC;AAE7F,eAAO,MAAM,gBAAgB,uHAE3B,CAAC"}

package/dist/staking-templates/templates/common/rewardDistribution.js

@@ -1,19 +1,16 @@
-import { z } from "../../../common/zod.js";
 import { AddressSchema } from "../../../common/index.js";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { Int256BigInt } from "../../../common/int256.js";
+import { z } from "zod";
 export const RewardDistributionComplexSchema = z
     .object({
-    duration: Int256Positive.openapi({
+    duration: Int256BigInt(z.bigint().positive()).openapi({
         description: `Duration applied for rewards to be fully distributed in seconds.\n\ne.g. if 5 minutes, rewards are expected to be fully distributed 5 minutes after the reward notification is successful`,
     }),
     distributor: AddressSchema.openapi({
         description: `Wallet address that is configured as distributor of rewards\n\nThe distributor must approve asset-spending at each notification of rewards`,
     }),
 })
-    .openapi({
-    ref: "RewardDistributionComplex",
-    description: "Details of Rewards Distribution",
-});
-export const RewardRateSchema = Int256Positive.openapi({
+    .openapi("RewardDistributionComplex", { description: "Details of Rewards Distribution", });
+export const RewardRateSchema = Int256BigInt(z.bigint().positive()).openapi({
     description: "Base campaign rate multiplier. How many Packets allocated to a Staker each second as a Reward",
 });

package/dist/staking-templates/templates/common/time.d.ts

@@ -1,2 +1,2 @@
-export declare const StartTimeSchema: import("zod").ZodString;
+export declare const StartTimeSchema: import("zod").ZodPipe<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "ISO", "out">, import("zod").ZodTransform<Date, string & import("zod").$brand<"ISO">>>;
 //# sourceMappingURL=time.d.ts.map

package/dist/staking-templates/templates/common/time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/time.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,yBAE1B,CAAC"}
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/time.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,yKAE1B,CAAC"}

package/dist/staking-templates/templates/common/time.js

@@ -1,4 +1,4 @@
-import { ISOSchema } from "../../../common/models/date.js";
-export const StartTimeSchema = ISOSchema.openapi({
+import { ISODate } from "../../../common/models/date.js";
+export const StartTimeSchema = ISODate().openapi({
     description: "Start time when Staking Pool starts (ISO string)",
 });

package/dist/staking-templates/templates/common/unstake.d.ts

@@ -1,56 +1,56 @@
-import { Factory } from "hono/factory";
 import { Env } from "hono";
+import { Factory } from "hono/factory";
 import { ITemplateHelper } from "./templates.js";
 export declare function createUnstakeRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         functionName: string;
+        address: `0x${string}`;
         abi: any[];
         args: any[];
     };
 }, 200, "json">>>, import("hono/types").H<Env, string, {
     in: {
         json: {
-            stakeId: string | number | bigint;
-            platform: `0x${string}`;
+            platform: string;
+            stakeId: string;
         };
     };
     out: {
         json: {
-            stakeId: bigint;
             platform: `0x${string}`;
+            stakeId: bigint;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         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: {
-            stakeId: string | number | bigint;
-            platform: `0x${string}`;
+            platform: string;
+            stakeId: string;
         };
     };
     out: {
         json: {
-            stakeId: bigint;
             platform: `0x${string}`;
+            stakeId: bigint;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        address: `0x${string}`;
         functionName: string;
+        address: `0x${string}`;
         abi: any[];
         args: any[];
     };

package/dist/staking-templates/templates/common/unstake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unstake.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/unstake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAI3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIjD,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmC/F"}
+{"version":3,"file":"unstake.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/unstake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmC/F"}

package/dist/staking-templates/templates/common/unstake.js

@@ -1,8 +1,8 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
 import { unstake } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { z } from "../../../common/zod.js";
 import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { z } from "zod";
 export function createUnstakeRoute(factory, template) {
     return factory.createHandlers(describeRoute({
         summary: "Unstake",