@evergonlabs/tmi-protocol-api 0.1.0

package/dist/fractions/activity/searchActivity.route.d.ts

@@ -0,0 +1,162 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { FractionSaleEventEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+export declare function createSearchActivityV0App<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash: `0x${string}`;
+    from: `0x${string}`;
+    metadata: {
+        type: FractionSaleEventEnum.CREATED;
+    } | {
+        status: import("@evergonlabs/tmi-protocol-indexer/schema").FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    } | {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    } | {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    } | {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    };
+}[], import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+                platform?: `0x${string}` | undefined;
+                campaignId?: string | number | bigint | undefined;
+                operationType?: FractionSaleEventEnum | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+                platform?: `0x${string}` | undefined;
+                campaignId?: bigint | undefined;
+                operationType?: FractionSaleEventEnum | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash: `0x${string}`;
+    from: `0x${string}`;
+    metadata: {
+        type: FractionSaleEventEnum.CREATED;
+    } | {
+        status: import("@evergonlabs/tmi-protocol-indexer/schema").FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    } | {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    } | {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    } | {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    };
+}[], 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: {
+            filter: {
+                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+                platform?: `0x${string}` | undefined;
+                campaignId?: string | number | bigint | undefined;
+                operationType?: FractionSaleEventEnum | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
+                platform?: `0x${string}` | undefined;
+                campaignId?: bigint | undefined;
+                operationType?: FractionSaleEventEnum | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash: `0x${string}`;
+    from: `0x${string}`;
+    metadata: {
+        type: FractionSaleEventEnum.CREATED;
+    } | {
+        status: import("@evergonlabs/tmi-protocol-indexer/schema").FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    } | {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    } | {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    } | {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    };
+}[], import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=searchActivity.route.d.ts.map

package/dist/fractions/activity/searchActivity.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchActivity.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/activity/searchActivity.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAQvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAiE3E"}

package/dist/fractions/activity/searchActivity.route.js

@@ -0,0 +1,56 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { and, desc, eq, sql } from "@ponder/client";
+import { z } from "../../common/zod.js";
+import { indexerClient } from "../../common/indexer/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { PageSchema } from "../../common/models/page.js";
+import { FractionSaleEventEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { PlatformContractAddress, CampaignIdSchema, TmiChainIdSchema } from "../../common/index.js";
+import { FractionActivityEntrySchema } from "./utils.js";
+export function createSearchActivityV0App(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search activity events",
+        description: "Search activity events by users, platforms and pools",
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Returns list of activity events within specified platforms and pools",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(FractionActivityEntrySchema)),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        page: PageSchema,
+        filter: z.object({
+            chainId: TmiChainIdSchema.optional(),
+            platform: PlatformContractAddress.optional(),
+            campaignId: CampaignIdSchema.optional(),
+            operationType: z.nativeEnum(FractionSaleEventEnum).optional(),
+        }),
+    })), async (c) => {
+        const { page, filter } = c.req.valid("json");
+        const { fractions: { fractionsSaleActivity }, } = indexerSchemas;
+        const result = await indexerClient.db.query.fractionsSaleActivity.findMany({
+            where: and(filter.chainId ? eq(fractionsSaleActivity.chainId, Number(filter.chainId)) : undefined, filter.platform ? eq(fractionsSaleActivity.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "bigint" ? eq(fractionsSaleActivity.saleId, filter.campaignId) : undefined, filter.operationType
+                ? sql `${fractionsSaleActivity.metadata}->>'type' = '${filter.operationType}'`
+                : undefined),
+            limit: page.limit,
+            offset: page.skip,
+            orderBy: desc(fractionsSaleActivity.createdAt),
+        });
+        return c.json(result.map((i) => FractionActivityEntrySchema.parse({
+            chainId: i.chainId,
+            platform: i.diamondAddress,
+            campaignId: i.saleId,
+            metadata: i.metadata,
+            from: i.from,
+            transactionHash: i.transactionHash,
+            createdAt: i.createdAt,
+            updatedAt: i.updatedAt,
+        })));
+    });
+}

package/dist/fractions/activity/utils.d.ts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { FractionSaleEventEnum, FractionSaleStatusEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+export declare const FractionActivityEntrySchema: z.ZodObject<z.objectUtil.extendShape<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodString;
+    transactionHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    from: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, {
+    metadata: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.CREATED>;
+    }, "strip", z.ZodTypeAny, {
+        type: FractionSaleEventEnum.CREATED;
+    }, {
+        type: FractionSaleEventEnum.CREATED;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.STATUS_UPDATE>;
+        status: z.ZodNativeEnum<typeof FractionSaleStatusEnum>;
+    }, "strip", z.ZodTypeAny, {
+        status: FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    }, {
+        status: FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.PURCHASE>;
+        purchaser: z.ZodString;
+        priceId: z.ZodString;
+        amountOfFractions: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    }, {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.CLAIM>;
+        receiver: z.ZodString;
+        semiFungibleBurntId: z.ZodString;
+        amountOfFractionsBurnt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    }, {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.REFUND>;
+        amount: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    }, {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.WITHDRAW>;
+        amount: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    }, {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<FractionSaleEventEnum.WITHDRAW_NON_WRAPPED>;
+        amount: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    }, {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    }>]>;
+}>, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    transactionHash: `0x${string}`;
+    from: `0x${string}`;
+    metadata: {
+        type: FractionSaleEventEnum.CREATED;
+    } | {
+        status: FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    } | {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    } | {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    } | {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    };
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    transactionHash: `0x${string}`;
+    from: `0x${string}`;
+    metadata: {
+        type: FractionSaleEventEnum.CREATED;
+    } | {
+        status: FractionSaleStatusEnum;
+        type: FractionSaleEventEnum.STATUS_UPDATE;
+    } | {
+        type: FractionSaleEventEnum.PURCHASE;
+        amountOfFractions: string;
+        priceId: string;
+        purchaser: string;
+    } | {
+        type: FractionSaleEventEnum.CLAIM;
+        receiver: string;
+        semiFungibleBurntId: string;
+        amountOfFractionsBurnt: string;
+    } | {
+        type: FractionSaleEventEnum.REFUND;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW;
+        amount: string;
+    } | {
+        type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
+        amount: string;
+    };
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/fractions/activity/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fractions/activity/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAmDzG,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpC,CAAC"}

package/dist/fractions/activity/utils.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { AddressSchema, TransactionHashSchema } from "@evergonlabs/tmi-utils/models";
+import { FractionSaleEventEnum, FractionSaleStatusEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { PlatformContractAddress, TmiChainIdSchema } from "../../common/index.js";
+const baseSchema = z.object({
+    chainId: TmiChainIdSchema,
+    platform: PlatformContractAddress,
+    campaignId: z.coerce.string(),
+    transactionHash: TransactionHashSchema,
+    from: AddressSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+const createdEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.CREATED),
+});
+const stateChangedEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.STATUS_UPDATE),
+    status: z.nativeEnum(FractionSaleStatusEnum),
+});
+const purchaseEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.PURCHASE),
+    purchaser: z.string(),
+    priceId: z.string(),
+    amountOfFractions: z.string(),
+});
+const claimEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.CLAIM),
+    receiver: z.string(),
+    semiFungibleBurntId: z.string(),
+    amountOfFractionsBurnt: z.string(),
+});
+const refundEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.REFUND),
+    amount: z.string(),
+});
+const withdrawEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.WITHDRAW),
+    amount: z.string(),
+});
+const withdrawNonWrappedEventSchema = z.object({
+    type: z.literal(FractionSaleEventEnum.WITHDRAW_NON_WRAPPED),
+    amount: z.string(),
+});
+export const FractionActivityEntrySchema = baseSchema
+    .extend({
+    metadata: z.discriminatedUnion("type", [
+        createdEventSchema,
+        stateChangedEventSchema,
+        purchaseEventSchema,
+        claimEventSchema,
+        refundEventSchema,
+        withdrawEventSchema,
+        withdrawNonWrappedEventSchema,
+    ]),
+})
+    .openapi({
+    ref: "FractionsActivity",
+});

package/dist/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

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