@evergonlabs/tmi-protocol-api 0.1.0

package/dist/common/indexer/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/common/indexer/schemas.ts"],"names":[],"mappings":"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"}

package/dist/common/indexer/schemas.js

@@ -0,0 +1,29 @@
+import { diamonds, fractionsClaim, fractionsMarket, fractionsPurchase, fractionsSale, fractionsWithdrawal, pools, poolsRelations, roleEvents, roles, stakeEvents, stakes, asset, fractionsFundingAsset, fractionsWrappedAsset, fractionsAssetsRelations, fractionsSaleRelations, fundingAssetsRelations, wrappedAssetsRelations, fractionsMarketRelations, fractionsPurchaseRelations, fractionsClaimRelations, fractionsWithdrawalRelations, fractionsSaleActivity, } from "@evergonlabs/tmi-protocol-indexer/schema";
+export const indexerSchemas = {
+    pools: pools,
+    poolsRelations: poolsRelations,
+    diamonds: diamonds,
+    roles: roles,
+    roleEvents: roleEvents,
+    stakes: stakes,
+    stakeEvents: stakeEvents,
+    assets: asset,
+    fractions: {
+        fractionsAssetsRelations: fractionsAssetsRelations,
+        fractionsMarkets: fractionsMarket,
+        fractionsMarketRelations: fractionsMarketRelations,
+        fractionsSales: fractionsSale,
+        fractionsSaleActivity: fractionsSaleActivity,
+        fractionsSaleRelations: fractionsSaleRelations,
+        fractionsWrappedAsset: fractionsWrappedAsset,
+        wrappedAssetsRelations: wrappedAssetsRelations,
+        fractionsFundingAsset: fractionsFundingAsset,
+        fundingAssetsRelations: fundingAssetsRelations,
+        fractionsPurchases: fractionsPurchase,
+        fractionsPurchaseRelations: fractionsPurchaseRelations,
+        fractionsClaims: fractionsClaim,
+        fractionsClaimRelations: fractionsClaimRelations,
+        fractionsWithdrawals: fractionsWithdrawal,
+        fractionsWithdrawalRelations: fractionsWithdrawalRelations,
+    },
+};

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

@@ -0,0 +1,30 @@
+import { z } from "../zod.js";
+export declare const AssetSchema: z.ZodObject<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    type: z.ZodString;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    decimals: z.ZodDefault<z.ZodNumber>;
+    burnable: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    type: string;
+    name: string;
+    address: `0x${string}`;
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    tokenId: string | null;
+    decimals: number;
+    burnable: boolean;
+}, {
+    symbol: string;
+    type: string;
+    name: string;
+    address: `0x${string}`;
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    tokenId: string | null;
+    decimals?: number | undefined;
+    burnable?: boolean | undefined;
+}>;
+//# sourceMappingURL=asset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../../../src/common/models/asset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAI9B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpB,CAAC"}

package/dist/common/models/asset.js

@@ -0,0 +1,21 @@
+import { z } from "../zod.js";
+import { TmiChainIdSchema } from "./chainId.js";
+import { AddressSchema } from "./viem.js";
+export const AssetSchema = z
+    .object({
+    chainId: TmiChainIdSchema,
+    address: AddressSchema,
+    type: z.string(),
+    symbol: z.string().openapi({
+        example: "TOKEN",
+    }),
+    name: z.string().openapi({
+        example: "My token",
+    }),
+    tokenId: z.union([z.string(), z.null()]),
+    decimals: z.number().default(0),
+    burnable: z.boolean().default(false),
+})
+    .openapi({
+    ref: "AssetMeta",
+});

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

@@ -0,0 +1,5 @@
+import { z } from "../zod.js";
+import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export declare const StakingChainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+export declare const TmiChainIdSchema: z.ZodType<TmiChainId, z.ZodTypeDef, TmiChainId>;
+//# sourceMappingURL=chainId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chainId.d.ts","sourceRoot":"","sources":["../../../src/common/models/chainId.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAC9B,OAAO,EAAE,UAAU,EAA6B,MAAM,yCAAyC,CAAC;AAEhG,eAAO,MAAM,cAAc,qEASvB,CAAC;AAEL,eAAO,MAAM,gBAAgB,iDASzB,CAAC"}

package/dist/common/models/chainId.js

@@ -0,0 +1,23 @@
+import { isSupportedChainId, supportedChains } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "../zod.js";
+import { isTmiChainId, tmiChainIds } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export const StakingChainId = z
+    .custom((x) => isSupportedChainId(x), {
+    message: "Unsupported chain id",
+})
+    .openapi({
+    type: "string",
+    enum: supportedChains.map((x) => x.toString()),
+    description: "Supported chain id",
+    example: "11155111",
+});
+export const TmiChainIdSchema = z
+    .custom((x) => isTmiChainId(x), {
+    message: "Unsupported chain id",
+})
+    .openapi({
+    type: "string",
+    enum: tmiChainIds.map((x) => BigInt(x).toString()),
+    description: "Supported chain id",
+    example: 11155111,
+});

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

@@ -0,0 +1,3 @@
+import { z } from "../zod.js";
+export declare const ISOSchema: z.ZodString;
+//# sourceMappingURL=date.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/common/models/date.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,eAAO,MAAM,SAAS,aAGpB,CAAC"}

package/dist/common/models/date.js

@@ -0,0 +1,5 @@
+import { z } from "../zod.js";
+export const ISOSchema = z.string().datetime().openapi({
+    format: "date-time",
+    description: "Date ISO format",
+});

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

@@ -0,0 +1,15 @@
+import { z } from "../zod.js";
+export declare const Erc721Schema: z.ZodObject<{
+    symbol: z.ZodString;
+    name: z.ZodString;
+    baseUri: z.ZodUnion<[z.ZodString, z.ZodEffects<z.ZodString, string, string>]>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    baseUri: string;
+}, {
+    symbol: string;
+    name: string;
+    baseUri: string;
+}>;
+//# sourceMappingURL=erc721.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"erc721.d.ts","sourceRoot":"","sources":["../../../src/common/models/erc721.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,eAAO,MAAM,YAAY;;;;;;;;;;;;EAkBrB,CAAC"}

package/dist/common/models/erc721.js

@@ -0,0 +1,21 @@
+import { HttpsUrlSchema, IpfsUrlSchema } from "@evergonlabs/tmi-utils/models";
+import { z } from "../zod.js";
+export const Erc721Schema = z
+    .object({
+    symbol: z.string().openapi({
+        example: "TOKEN",
+        description: "Symbol for ERC721 that is going to be used on-chain",
+    }),
+    name: z.string().openapi({
+        example: "My Staking Platform",
+        description: "Name for ERC721 that is going to be used on-chain",
+    }),
+    baseUri: z.union([IpfsUrlSchema, HttpsUrlSchema]).openapi({
+        example: "ipfs://",
+        type: "string",
+        description: `Use ipfs base uri to maintain decentralized accessibility of metadata.\n\nYou may also specify https but it's not recommended`,
+    }),
+})
+    .openapi({
+    ref: "Erc721Meta",
+});

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

@@ -0,0 +1,8 @@
+export * from "./routes.js";
+export * from "./transaction.js";
+export * from "./viem.js";
+export * from "./chainId.js";
+export * from "./platform.js";
+export * from "./percent.js";
+export * from "./asset.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/common/models/index.js

@@ -0,0 +1,7 @@
+export * from "./routes.js";
+export * from "./transaction.js";
+export * from "./viem.js";
+export * from "./chainId.js";
+export * from "./platform.js";
+export * from "./percent.js";
+export * from "./asset.js";

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

@@ -0,0 +1,12 @@
+import { z } from "../zod.js";
+export declare const PageSchema: z.ZodObject<{
+    skip: z.ZodNumber;
+    limit: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    skip: number;
+    limit: number;
+}, {
+    skip: number;
+    limit: number;
+}>;
+//# sourceMappingURL=page.d.ts.map

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

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

package/dist/common/models/page.js

@@ -0,0 +1,15 @@
+import { z } from "../zod.js";
+export const PageSchema = z
+    .object({
+    skip: z.number().min(0).openapi({
+        description: "How many entries to skip from the start",
+    }),
+    limit: z.number().min(0).max(50).openapi({
+        description: "How many items per page should be retrieved",
+        maximum: 50,
+    }),
+})
+    .openapi({
+    ref: "PageRequest",
+    description: "Provide page details in order to implement pagination",
+});

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,6 @@
+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/platform.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const PlatformContractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+export declare const StakeIdSchema: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+export declare const PoolIdSchema: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+export declare const CampaignIdSchema: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+export declare const FractionsMarketTemplateSchema: z.ZodEnum<["default", "compilot", "continuous-withdrawal", "continuous-withdrawal-nid"]>;
+export declare const FractionsSaleStatusSchema: z.ZodEnum<["created", "approved", "rejected", "finalized", "refunded"]>;
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/common/models/platform.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB,uDAElC,CAAC;AAEH,eAAO,MAAM,aAAa,iFAGxB,CAAC;AAEH,eAAO,MAAM,YAAY,iFAGvB,CAAC;AAEH,eAAO,MAAM,gBAAgB,iFAG3B,CAAC;AAEH,eAAO,MAAM,6BAA6B,0FAKtC,CAAC;AAEL,eAAO,MAAM,yBAAyB,yEAGpC,CAAC"}

package/dist/common/models/platform.js

@@ -0,0 +1,28 @@
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { AddressSchema } from "./viem.js";
+import { z } from "zod";
+export const PlatformContractAddress = AddressSchema.openapi({
+    description: "Address of deployed Platform contract",
+});
+export const StakeIdSchema = Int256Positive.openapi({
+    description: "Id of a Stake position (NFT Id)",
+    example: "1",
+});
+export const PoolIdSchema = Int256Positive.openapi({
+    description: "Id of a Pool",
+    example: "1",
+});
+export const CampaignIdSchema = Int256Positive.openapi({
+    description: "Id of a Sale",
+    example: "1",
+});
+export const FractionsMarketTemplateSchema = z
+    .enum(["default", "compilot", "continuous-withdrawal", "continuous-withdrawal-nid"])
+    .openapi({
+    description: "Template of deployed Fractions Market contract",
+    example: "compilot",
+});
+export const FractionsSaleStatusSchema = z.enum(["created", "approved", "rejected", "finalized", "refunded"]).openapi({
+    description: "Status of deployed Fractions Sale",
+    example: "created",
+});

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

@@ -0,0 +1,16 @@
+import { z } from "../zod.js";
+export declare const ErrorSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    message: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    message: string;
+    name: string;
+}, {
+    success: false;
+    message: string;
+    name: string;
+}>;
+export declare function toError(error: Error): z.output<typeof ErrorSchema>;
+//# sourceMappingURL=routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../src/common/models/routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,eAAO,MAAM,WAAW;;;;;;;;;;;;EAItB,CAAC;AAEH,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAMlE"}

package/dist/common/models/routes.js

@@ -0,0 +1,13 @@
+import { z } from "../zod.js";
+export const ErrorSchema = z.object({
+    success: z.literal(false),
+    message: z.string(),
+    name: z.string(),
+});
+export function toError(error) {
+    return {
+        success: false,
+        message: error.message,
+        name: error.name,
+    };
+}

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const SaleIdSchema: z.ZodObject<{
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    campaignId: bigint;
+    market: `0x${string}`;
+}, {
+    campaignId: bigint;
+    market: `0x${string}`;
+}>;
+//# sourceMappingURL=saleId.d.ts.map

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

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

package/dist/common/models/saleId.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import { AddressSchema } from "./viem.js";
+export const SaleIdSchema = z.object({
+    market: AddressSchema,
+    campaignId: z.coerce.bigint(),
+});

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

@@ -0,0 +1,90 @@
+import { ITransaction } from "@evergonlabs/tmi-protocol-types/evm";
+import { z } from "../zod.js";
+export declare const TransactionSchema: z.ZodObject<{
+    data: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    to: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    details: z.ZodObject<{
+        functionName: z.ZodString;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        abi: z.ZodArray<z.ZodAny, "many">;
+        args: z.ZodArray<z.ZodAny, "many">;
+    }, "strip", z.ZodTypeAny, {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    }, {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, {
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}>;
+export declare const GatedTransactionSchema: z.ZodObject<z.objectUtil.extendShape<{
+    data: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    to: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    details: z.ZodObject<{
+        functionName: z.ZodString;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        abi: z.ZodArray<z.ZodAny, "many">;
+        args: z.ZodArray<z.ZodAny, "many">;
+    }, "strip", z.ZodTypeAny, {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    }, {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    }>;
+}, {}>, "strip", z.ZodTypeAny, {
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, {
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}>;
+export declare function toTransaction(tx: ITransaction, encodeData?: boolean): z.infer<typeof TransactionSchema>;
+export declare const SentTransactionParamsSchema: z.ZodObject<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    hash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    hash: `0x${string}`;
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    hash: `0x${string}`;
+}>;
+//# sourceMappingURL=transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/common/models/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,OAAO,EAAE,CAAC,EAAE,MAAM,WAAW,CAAC;AAE9B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoB1B,CAAC;AAEL,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA+B,CAAC;AAEnE,wBAAgB,aAAa,CAAC,EAAE,EAAE,YAAY,EAAE,UAAU,GAAE,OAAe,GAepE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CACvC;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;EAatC,CAAC"}

package/dist/common/models/transaction.js

@@ -0,0 +1,57 @@
+import { encodeFunctionData } from "viem";
+import { AddressSchema, HashSchema, HexStringSchema } from "./viem.js";
+import { TmiChainIdSchema } from "./chainId.js";
+import { z } from "../zod.js";
+export const TransactionSchema = z
+    .object({
+    data: HexStringSchema.openapi({ description: "Encoded contract execution data" }),
+    to: AddressSchema.openapi({ description: "Address of a contract to interact with" }),
+    details: z.object({
+        functionName: z.string().openapi({ description: "Function name" }),
+        address: AddressSchema.openapi({ description: "Address of a contract to interact with" }),
+        abi: z.array(z.any()).openapi({
+            description: "ABI of a contract. Can be used for error and data decoding",
+            type: "array",
+        }),
+        args: z.array(z.any()).openapi({
+            description: "Decoded arguments",
+            type: "array",
+        }),
+    }),
+})
+    .openapi({
+    ref: "Transaction",
+    description: "Details of a transaction that can be sent to the blockchain",
+});
+export const GatedTransactionSchema = TransactionSchema.extend({});
+export function toTransaction(tx, encodeData = false) {
+    return {
+        to: tx.address,
+        data: encodeData
+            ? encodeFunctionData({
+                abi: tx.abi,
+                args: tx.args,
+                functionName: tx.functionName,
+            })
+            : "",
+        details: {
+            abi: tx.abi,
+            args: tx.args,
+            functionName: tx.functionName,
+        },
+    };
+}
+export const SentTransactionParamsSchema = z.object({
+    chainId: TmiChainIdSchema.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    hash: HashSchema.openapi({
+        param: {
+            name: "hash",
+            in: "query",
+        },
+    }),
+});

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

@@ -0,0 +1,4 @@
+export declare const HexStringSchema: import("zod").ZodType<`0x${string}`, import("zod").ZodTypeDef, `0x${string}`>;
+export declare const AddressSchema: import("zod").ZodType<`0x${string}`, import("zod").ZodTypeDef, `0x${string}`>;
+export declare const HashSchema: import("zod").ZodType<`0x${string}`, import("zod").ZodTypeDef, `0x${string}`>;
+//# sourceMappingURL=viem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["../../../src/common/models/viem.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,+EAG1B,CAAC;AAEH,eAAO,MAAM,aAAa,+EAGxB,CAAC;AAEH,eAAO,MAAM,UAAU,+EAMrB,CAAC"}

package/dist/common/models/viem.js

@@ -0,0 +1,17 @@
+import { HexStringSchema as _HexStringSchema, AddressSchema as _AddressSchema } from "@evergonlabs/tmi-utils/models";
+import { zeroAddress } from "viem";
+export const HexStringSchema = _HexStringSchema.openapi({
+    type: "string",
+    example: "0x",
+});
+export const AddressSchema = _AddressSchema.openapi({
+    type: "string",
+    example: zeroAddress,
+});
+export const HashSchema = _HexStringSchema.openapi({
+    type: "string",
+    minLength: 66,
+    maxLength: 66,
+    example: "0x02dfb1fcdb76a64b88e5b31ab393bf3302e2fade282123bd9ca473d0e26a25df",
+    description: "Transaction hash",
+});

package/dist/common/roles/erc20-gated-roles.d.ts

@@ -0,0 +1,7 @@
+export declare enum Erc20GatedRole {
+    WHITELISTED_SPENDER_ROLE = "WHITELISTED_SPENDER_ROLE",
+    DEFAULT_ADMIN_ROLE = "DEFAULT_ADMIN_ROLE",
+    MINTER_ROLE = "MINTER_ROLE"
+}
+export declare function convertRoleToHash(role: Erc20GatedRole): `0x${string}`;
+//# sourceMappingURL=erc20-gated-roles.d.ts.map

package/dist/common/roles/erc20-gated-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20-gated-roles.d.ts","sourceRoot":"","sources":["../../../src/common/roles/erc20-gated-roles.ts"],"names":[],"mappings":"AAEA,oBAAY,cAAc;IACxB,wBAAwB,6BAA6B;IACrD,kBAAkB,uBAAuB;IACzC,WAAW,gBAAgB;CAC5B;AAGD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,KAAK,MAAM,EAAE,CAGrE"}

package/dist/common/roles/erc20-gated-roles.js

@@ -0,0 +1,13 @@
+import { keccak256, toHex } from "viem";
+export var Erc20GatedRole;
+(function (Erc20GatedRole) {
+    Erc20GatedRole["WHITELISTED_SPENDER_ROLE"] = "WHITELISTED_SPENDER_ROLE";
+    Erc20GatedRole["DEFAULT_ADMIN_ROLE"] = "DEFAULT_ADMIN_ROLE";
+    Erc20GatedRole["MINTER_ROLE"] = "MINTER_ROLE";
+})(Erc20GatedRole || (Erc20GatedRole = {}));
+// Convert role string to keccak256 hash
+export function convertRoleToHash(role) {
+    if (role === Erc20GatedRole.DEFAULT_ADMIN_ROLE)
+        return toHex(0, { size: 32 });
+    return keccak256(toHex(role));
+}

package/dist/common/tag.d.ts

@@ -0,0 +1,7 @@
+export type ITag<T extends string = string> = {
+    tag: T;
+};
+export declare function createTag<T extends string>(tag: T): {
+    tag: T;
+};
+//# sourceMappingURL=tag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../src/common/tag.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAC5C,GAAG,EAAE,CAAC,CAAC;CACR,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC;;EAIjD"}

package/dist/common/tag.js

@@ -0,0 +1,5 @@
+export function createTag(tag) {
+    return {
+        tag: tag,
+    };
+}

package/dist/common/zod.d.ts

@@ -0,0 +1,3 @@
+import "zod-openapi/extend";
+export * from "zod";
+//# sourceMappingURL=zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/common/zod.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAC5B,cAAc,KAAK,CAAC"}

package/dist/common/zod.js

@@ -0,0 +1,2 @@
+import "zod-openapi/extend";
+export * from "zod";

package/dist/error.d.ts

@@ -0,0 +1,3 @@
+import { Env, ErrorHandler } from "hono";
+export declare function createErrorHandler<E extends Env>(): ErrorHandler<E>;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAGzC,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,KAAK,YAAY,CAAC,CAAC,CAAC,CAYnE"}

package/dist/error.js

@@ -0,0 +1,16 @@
+export function createErrorHandler() {
+    return (err, c) => {
+        console.log(err);
+        return c.json({
+            success: false,
+            message: err.message || "Unexpected Error",
+            name: err.name || "UnknownError",
+        }, extractCode(err));
+    };
+}
+function extractCode(err) {
+    if ("code" in err && typeof err.code === "number") {
+        return err.code;
+    }
+    return 500;
+}