@evergonlabs/tmi-protocol-api 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"approveSale.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/approveSale/v0/approveSale.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAG3B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,wBAAwB;;;;;;;;;EAGnC,CAAC;AAkBH,wBAAgB,+BAA+B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAUjF"}

package/dist/src/fractions/approveSale/v0/approveSale.route.js

@@ -0,0 +1,31 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { buildApproveSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { z } from "zod";
+export const ApproveSaleRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    campaignId: z.coerce.bigint().nonnegative(),
+});
+const route = describeRoute({
+    summary: "Approve a sale",
+    description: "Returns transaction data for approving a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a sale",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createApproveSalesTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", ApproveSaleRequestSchema.openapi({ ref: "ApproveSaleRequestSchema" })), async (c) => {
+        const { marketAddress, campaignId } = c.req.valid("json");
+        const tx = buildApproveSaleTx({ market: marketAddress, campaignId: campaignId });
+        return c.json(toTransaction(tx));
+    });
+}

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

@@ -0,0 +1,203 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { z } from "zod";
+export declare const ApproveWrapperRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    wrapperAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    wrapperAddress: `0x${string}`;
+    marketAddress: `0x${string}`;
+}, {
+    wrapperAddress: `0x${string}`;
+    marketAddress: `0x${string}`;
+}>;
+export declare const ApproveErc20SpendingToWrapper: z.ZodObject<{
+    wrapperAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    erc20Address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amount: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    wrapperAddress: `0x${string}`;
+    amount: bigint;
+    erc20Address: `0x${string}`;
+}, {
+    wrapperAddress: `0x${string}`;
+    amount: bigint;
+    erc20Address: `0x${string}`;
+}>;
+export declare const ApproveErc721SpendingToWrapper: z.ZodObject<{
+    wrapperAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    erc721Address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    wrapperAddress: `0x${string}`;
+    erc721Address: `0x${string}`;
+}, {
+    wrapperAddress: `0x${string}`;
+    erc721Address: `0x${string}`;
+}>;
+export declare function createApproveWrapperTransactionV0<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: {
+            wrapperAddress: `0x${string}`;
+            marketAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            wrapperAddress: `0x${string}`;
+            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: {
+            wrapperAddress: `0x${string}`;
+            marketAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            wrapperAddress: `0x${string}`;
+            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">>>];
+export declare function createApproveErc20SpendingToWrapper<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: {
+            wrapperAddress: `0x${string}`;
+            amount: bigint;
+            erc20Address: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            wrapperAddress: `0x${string}`;
+            amount: bigint;
+            erc20Address: `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: {
+            wrapperAddress: `0x${string}`;
+            amount: bigint;
+            erc20Address: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            wrapperAddress: `0x${string}`;
+            amount: bigint;
+            erc20Address: `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">>>];
+export declare function createApproveErc721SpendingToWrapper<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: {
+            wrapperAddress: `0x${string}`;
+            erc721Address: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            wrapperAddress: `0x${string}`;
+            erc721Address: `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: {
+            wrapperAddress: `0x${string}`;
+            erc721Address: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            wrapperAddress: `0x${string}`;
+            erc721Address: `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=approveWrapper.route.d.ts.map

package/dist/src/fractions/approveWrapper/v0/approveWrapper.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approveWrapper.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/approveWrapper/v0/approveWrapper.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAO3B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B;;;;;;;;;EAGtC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;EAGzC,CAAC;AAkBH,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAUnF;AAkBD,wBAAgB,mCAAmC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAUrF;AAkBD,wBAAgB,oCAAoC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAUtF"}

package/dist/src/fractions/approveWrapper/v0/approveWrapper.route.js

@@ -0,0 +1,84 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { buildApproveErc20SpendingToWrapperTx, buildApproveErc721SpendingToWrapperTx, buildApproveWrapperTx, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { z } from "zod";
+export const ApproveWrapperRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    wrapperAddress: AddressSchema,
+});
+export const ApproveErc20SpendingToWrapper = z.object({
+    wrapperAddress: AddressSchema,
+    erc20Address: AddressSchema,
+    amount: z.coerce.bigint().positive(),
+});
+export const ApproveErc721SpendingToWrapper = z.object({
+    wrapperAddress: AddressSchema,
+    erc721Address: AddressSchema,
+});
+const route = describeRoute({
+    summary: "Approve a wrapper",
+    description: "Returns transaction data for approving a wrapper",
+    tags: ["Fractions Approvals"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a wrapper",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createApproveWrapperTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", ApproveWrapperRequestSchema.openapi({ ref: "ApproveWrapperRequestSchema" })), async (c) => {
+        const { marketAddress, wrapperAddress } = c.req.valid("json");
+        const tx = buildApproveWrapperTx(marketAddress, wrapperAddress);
+        return c.json(toTransaction(tx));
+    });
+}
+const route_erc20 = describeRoute({
+    summary: "Approve wrapped ERC20 spending",
+    description: "Returns transaction data for approving a wrapper as a spender of wrapped ERC20",
+    tags: ["Fractions Approvals"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a wrapper",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createApproveErc20SpendingToWrapper(factory) {
+    return factory.createHandlers(route_erc20, validator("json", ApproveErc20SpendingToWrapper.openapi({ ref: "ApproveErc20SpendingToWrapper" })), async (c) => {
+        const { wrapperAddress, erc20Address, amount } = c.req.valid("json");
+        const tx = buildApproveErc20SpendingToWrapperTx(wrapperAddress, erc20Address, amount);
+        return c.json(toTransaction(tx));
+    });
+}
+const route_erc721 = describeRoute({
+    summary: "Approve wrapped ERC721 spending",
+    description: "Returns transaction data for approving a wrapper",
+    tags: ["Fractions Approvals"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a wrapper",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createApproveErc721SpendingToWrapper(factory) {
+    return factory.createHandlers(route_erc721, validator("json", ApproveErc721SpendingToWrapper.openapi({ ref: "ApproveErc721SpendingToWrapper" })), async (c) => {
+        const { wrapperAddress, erc721Address } = c.req.valid("json");
+        const tx = buildApproveErc721SpendingToWrapperTx(wrapperAddress, erc721Address);
+        return c.json(toTransaction(tx));
+    });
+}

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

@@ -0,0 +1,68 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "zod";
+export declare const CompleteSaleRequestSchema: 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 createCompleteSalesTransactionV0<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=completeSale.route.d.ts.map

package/dist/src/fractions/completeSale/v0/completeSale.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completeSale.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/completeSale/v0/completeSale.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,yBAAyB;;;;;;;;;EAGpC,CAAC;AAkBH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAYlF"}

package/dist/src/fractions/completeSale/v0/completeSale.route.js

@@ -0,0 +1,31 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { buildFinishSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { z } from "zod";
+export const CompleteSaleRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    campaignId: z.coerce.bigint().nonnegative(),
+});
+const route = describeRoute({
+    summary: "Complete a sale",
+    description: "Returns transaction data for completing a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for completing a sale",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createCompleteSalesTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", CompleteSaleRequestSchema.openapi({ ref: "CompleteSaleRequestSchema" })), async (c) => {
+        const { marketAddress, campaignId } = c.req.valid("json");
+        const tx = buildFinishSaleTx({ market: marketAddress, campaignId: campaignId });
+        return c.json(toTransaction(tx));
+    });
+}