@evergonlabs/tmi-protocol-api 0.1.0

package/dist/src/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/src/common/indexer/schemas.js

@@ -0,0 +1,14 @@
+import { diamonds, fractionEvents, fractionsMarkets, pools, poolsRelations, roleEvents, roles, stakeEvents, stakes, } from "@evergonlabs/tmi-protocol-indexer/schema";
+export const indexerSchemas = {
+    pools: pools,
+    poolsRelations: poolsRelations,
+    diamonds: diamonds,
+    roles: roles,
+    roleEvents: roleEvents,
+    stakes: stakes,
+    stakeEvents: stakeEvents,
+    fractions: {
+        fractionsMarkets: fractionsMarkets,
+        fractionEvents: fractionEvents,
+    },
+};

package/dist/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/common/models/index.d.ts

@@ -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";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/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"}

package/dist/src/common/models/index.js

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

package/dist/src/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/src/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/src/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/src/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/src/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/src/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/src/common/models/platform.d.ts

@@ -0,0 +1,4 @@
+export declare const PlatformContractAddress: import("zod").ZodType<`0x${string}`, import("zod").ZodTypeDef, `0x${string}`>;
+export declare const StakeIdSchema: import("zod").ZodPipeline<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBigInt]>, import("zod").ZodBigInt>;
+export declare const PoolIdSchema: import("zod").ZodPipeline<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBigInt]>, import("zod").ZodBigInt>;
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../../src/common/models/platform.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,uBAAuB,+EAElC,CAAC;AAEH,eAAO,MAAM,aAAa,yJAGxB,CAAC;AAEH,eAAO,MAAM,YAAY,yJAGvB,CAAC"}

package/dist/src/common/models/platform.js

@@ -0,0 +1,13 @@
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { AddressSchema } from "./viem.js";
+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",
+});

package/dist/src/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/src/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/src/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/src/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/src/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/src/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/src/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): z.infer<typeof TransactionSchema>;
+export declare const SentTransactionParamsSchema: z.ZodObject<{
+    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+    hash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    chainId: "11155111" | "31337";
+    hash: `0x${string}`;
+}, {
+    chainId: "11155111" | "31337";
+    hash: `0x${string}`;
+}>;
+//# sourceMappingURL=transaction.d.ts.map

package/dist/src/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,GAavC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CACvC;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;EAetC,CAAC"}

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

@@ -0,0 +1,57 @@
+import { encodeFunctionData } from "viem";
+import { AddressSchema, HashSchema, HexStringSchema } from "./viem.js";
+import { StakingChainId } 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) {
+    return {
+        to: tx.address,
+        data: 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: StakingChainId.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+        example: "11155111",
+    }),
+    hash: HashSchema.openapi({
+        param: {
+            name: "hash",
+            in: "query",
+        },
+        example: "0x",
+    }),
+});

package/dist/src/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/src/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,+EAIrB,CAAC"}

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

@@ -0,0 +1,15 @@
+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",
+    example: "0x",
+    description: "Transaction hash",
+});

package/dist/src/common/openapi.d.ts

@@ -0,0 +1,4 @@
+import { OpenApiSpecsOptions } from "hono-openapi";
+import { IApiConfig } from "../common/app.js";
+export declare function getOpenApiSpec(config: IApiConfig, baseUrl: string): OpenApiSpecsOptions;
+//# sourceMappingURL=openapi.d.ts.map

package/dist/src/common/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../../src/common/openapi.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAInD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAqB9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,mBAAmB,CAmBvF"}

package/dist/src/common/openapi.js

@@ -0,0 +1,40 @@
+import { resolver } from "hono-openapi/zod";
+import { version } from "../common/version.js";
+import { z } from "../common/zod.js";
+const ZodErrorSchema = z
+    .object({
+    status: z.literal(400),
+    message: z.string(),
+})
+    .openapi({
+    ref: "ZodError",
+    description: "Validation error",
+});
+const ZodResponse = {
+    description: "Zod Error",
+    content: {
+        "application/json": {
+            schema: resolver(ZodErrorSchema),
+        },
+    },
+};
+export function getOpenApiSpec(config, baseUrl) {
+    return {
+        documentation: {
+            info: {
+                title: config.title,
+                version: version,
+                description: config.description,
+            },
+            servers: [
+                {
+                    url: baseUrl,
+                },
+            ],
+        },
+        defaultOptions: {
+            GET: { responses: { 400: ZodResponse } },
+            POST: { responses: { 400: ZodResponse } },
+        },
+    };
+}

package/dist/src/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/src/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/src/common/tag.js

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

package/dist/src/common/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/src/common/version.d.ts.map

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

package/dist/src/common/version.js

@@ -0,0 +1,2 @@
+import pkg from "../../package.json";
+export const version = pkg.version;

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

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

package/dist/src/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/src/common/zod.js

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

package/dist/src/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/src/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/src/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;
+}

package/dist/src/fractions/approveSale/v0/approveSale.route.d.ts

@@ -0,0 +1,68 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { z } from "zod";
+export declare const ApproveSaleRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    campaignId: bigint;
+    marketAddress: `0x${string}`;
+}, {
+    campaignId: bigint;
+    marketAddress: `0x${string}`;
+}>;
+export declare function createApproveSalesTransactionV0<E extends Env>(factory: Factory<E>): [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[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            campaignId: bigint;
+            marketAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            marketAddress: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            campaignId: bigint;
+            marketAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            marketAddress: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=approveSale.route.d.ts.map