@evergonlabs/tmi-protocol-api 0.9.0 → 0.10.0-rc.1

package/dist/fractions/sales/vesting/v0/claimVestedTokens.route.d.ts

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

package/dist/fractions/sales/vesting/v0/claimVestedTokens.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claimVestedTokens.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/sales/vesting/v0/claimVestedTokens.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAG3B,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAC;AAkBH,wBAAgB,kCAAkC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkBpF"}

package/dist/fractions/sales/vesting/v0/claimVestedTokens.route.js

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { claimVestedTokens } from "@evergonlabs/tmi-protocol-fractions-sdk";
-export const ClaimVestedTokensRequestSchema = z.object({
-    address: AddressSchema,
-    campaignId: z.coerce.bigint().positive(),
-    amountOfFractions: z.coerce.bigint().positive(),
-    itToBurn: z.coerce.bigint().nonnegative(),
-});
-const route = describeRoute({
-    summary: "Claim vested tokens",
-    description: "Returns transaction data for claiming vested tokens from a campaign",
-    tags: ["Fractions Vesting"],
-    responses: {
-        200: {
-            description: "Returns transaction data for claiming vested tokens",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function createClaimVestedTokensTransaction(factory) {
-    return factory.createHandlers(route, validator("json", ClaimVestedTokensRequestSchema.openapi({ ref: "ClaimVestedTokensRequestSchema" })), async (c) => {
-        const request = c.req.valid("json");
-        try {
-            const tx = claimVestedTokens(request);
-            return c.json(toTransaction(tx));
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                return c.json({ error: error.message }, 400);
-            }
-            return c.json({ error: "An unknown error occurred" }, 500);
-        }
-    });
-}

package/dist/fractions/sales/vesting/v0/editCliff.route.d.ts

@@ -1,87 +0,0 @@
-import { Factory } from "hono/factory";
-import { Env } from "hono";
-import { z } from "zod";
-export declare const EditCliffRequestSchema: z.ZodObject<{
-    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    saleId: z.ZodBigInt;
-    newCliffDate: z.ZodDate;
-}, "strip", z.ZodTypeAny, {
-    saleId: bigint;
-    marketAddress: `0x${string}`;
-    newCliffDate: Date;
-}, {
-    saleId: bigint;
-    marketAddress: `0x${string}`;
-    newCliffDate: Date;
-}>;
-export declare function createEditCliffTransactionApp<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<(Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            saleId: bigint;
-            marketAddress: `0x${string}`;
-            newCliffDate: Date;
-        };
-    };
-    out: {
-        json: {
-            saleId: bigint;
-            marketAddress: `0x${string}`;
-            newCliffDate: Date;
-        };
-    };
-}, Promise<(Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            saleId: bigint;
-            marketAddress: `0x${string}`;
-            newCliffDate: Date;
-        };
-    };
-    out: {
-        json: {
-            saleId: bigint;
-            marketAddress: `0x${string}`;
-            newCliffDate: Date;
-        };
-    };
-}, Promise<(Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>>];
-//# sourceMappingURL=editCliff.route.d.ts.map

package/dist/fractions/sales/vesting/v0/editCliff.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"editCliff.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/sales/vesting/v0/editCliff.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,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAkBH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkB/E"}

package/dist/fractions/sales/vesting/v0/editCliff.route.js

@@ -1,40 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { buildEditCliffTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { z } from "zod";
-export const EditCliffRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    saleId: z.coerce.bigint().positive(),
-    newCliffDate: z.coerce.date(),
-});
-const route = describeRoute({
-    summary: "Edit the cliff of a vesting schedule",
-    description: "Returns transaction data for updating the cliff date in a vesting schedule",
-    tags: ["Fractions Vesting"],
-    responses: {
-        200: {
-            description: "Returns transaction data for editing the cliff date",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function createEditCliffTransactionApp(factory) {
-    return factory.createHandlers(route, validator("json", EditCliffRequestSchema.openapi({ ref: "EditCliffRequestSchema" })), async (c) => {
-        const { marketAddress, saleId, newCliffDate } = c.req.valid("json");
-        try {
-            const tx = buildEditCliffTx(marketAddress, saleId, newCliffDate);
-            return c.json(toTransaction(tx));
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                return c.json({ error: error.message }, 400);
-            }
-            return c.json({ error: "An unknown error occurred" }, 500);
-        }
-    });
-}

package/dist/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.d.ts

@@ -1,48 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createGetClaimVestedTokensEventRoute<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    campaignId: string;
-    receiver: `0x${string}`;
-    burnId: string;
-    nextBurnId: string | null;
-    amountOfFractionsBurnt: string;
-}, 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            hash: string | string[];
-        };
-    };
-    out: {
-        query: {
-            chainId: 1 | 31337 | 11155111 | 72080;
-            hash: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    campaignId: string;
-    receiver: `0x${string}`;
-    burnId: string;
-    nextBurnId: string | null;
-    amountOfFractionsBurnt: string;
-}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            hash: string | string[];
-        };
-    };
-    out: {
-        query: {
-            chainId: 1 | 31337 | 11155111 | 72080;
-            hash: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    campaignId: string;
-    receiver: `0x${string}`;
-    burnId: string;
-    nextBurnId: string | null;
-    amountOfFractionsBurnt: string;
-}, 200, "json">>>];
-//# sourceMappingURL=parseClaimVestedTokensEvent.d.ts.map

package/dist/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseClaimVestedTokensEvent.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAWvC,wBAAgB,oCAAoC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgDtF"}

package/dist/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.js

@@ -1,57 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { waitForTransactionReceipt } from "viem/actions";
-import { AddressSchema, CampaignIdSchema, 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 { Int256Positive } from "@evergonlabs/tmi-utils/models";
-import { parseClaimVestedTokensEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
-export function createGetClaimVestedTokensEventRoute(factory) {
-    return factory.createHandlers(describeRoute({
-        summary: "Get ClaimVestedTokens Event",
-        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`claimVestedTokens\` action`,
-        tags: ["Fractions Vesting"],
-        responses: {
-            200: {
-                description: "Returns parsed event log",
-                content: {
-                    "application/json": {
-                        schema: resolver(z.object({
-                            campaignId: CampaignIdSchema,
-                            receiver: AddressSchema,
-                            burnId: Int256Positive,
-                            nextBurnId: z.union([Int256Positive, z.null()]),
-                            amountOfFractionsBurnt: Int256Positive,
-                        })),
-                    },
-                },
-            },
-        },
-    }), validator("query", SentTransactionParamsSchema), async (c) => {
-        const params = c.req.valid("query");
-        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
-            hash: params.hash,
-        });
-        const result = parseClaimVestedTokensEvent(receipt.logs);
-        if (!result) {
-            throw new UnableParseClaimVestedTokensEvent();
-        }
-        const { campaignId, receiver, burnId, nextBurnId, amountOfFractionsBurnt } = result;
-        return c.json({
-            campaignId: campaignId.toString(),
-            receiver: receiver,
-            burnId: burnId.toString(),
-            nextBurnId: nextBurnId !== null ? nextBurnId.toString() : null,
-            amountOfFractionsBurnt: amountOfFractionsBurnt.toString(),
-        }, 200);
-    });
-}
-class UnableParseClaimVestedTokensEvent extends HttpError {
-    constructor() {
-        super(500, {
-            message: `Can't parse ClaimVestedTokens transaction. Make sure you're passing transaction that is generated by \`claimVestedTokens\` action`,
-            name: "UnableParseClaimVestedTokensEvent",
-        });
-    }
-}

package/dist/fractions/withdraw/v0/withdraw.route.d.ts

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

package/dist/fractions/withdraw/v0/withdraw.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withdraw.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/withdraw/v0/withdraw.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,qBAAqB;;;;;;;;;EAGhC,CAAC;AAkBH,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAU5F"}

package/dist/fractions/withdraw/v0/withdraw.route.js

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

package/dist/general/balance-client.d.ts

@@ -1,13 +0,0 @@
-import { Address } from "viem";
-import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
-export type TokenBalance = {
-    balance: bigint;
-    contractAddress: Address;
-    decimals: number | undefined;
-    name: string;
-    symbol: string;
-    type: "ERC-20" | "ERC-721" | "ERC-1155";
-    id: bigint | undefined;
-};
-export declare function getTokenBalance(wallet: Address, chainId: TmiChainId, contracts?: Address[]): Promise<TokenBalance[]>;
-//# sourceMappingURL=balance-client.d.ts.map

package/dist/general/balance-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"balance-client.d.ts","sourceRoot":"","sources":["../../src/general/balance-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAI/B,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;CACxB,CAAC;AAQF,wBAAsB,eAAe,CACnC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,UAAU,EACnB,SAAS,CAAC,EAAE,OAAO,EAAE,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC,CAsBzB"}

package/dist/general/balance-client.js

@@ -1,26 +0,0 @@
-import { getBalancesApi } from "../common/blockchain.js";
-import axios from "axios";
-export async function getTokenBalance(wallet, chainId, contracts) {
-    const url = getBalancesApi(chainId);
-    try {
-        const result = await axios.get(url, {
-            params: {
-                module: "account",
-                action: "tokenlist",
-                address: wallet,
-            },
-        });
-        if (contracts) {
-            return result.data.result.filter((token) => contracts.includes(token.contractAddress));
-        }
-        else {
-            return result.data.result;
-        }
-    }
-    catch (error) {
-        if (axios.isAxiosError(error)) {
-            throw new Error(`Network error: ${error.message}`);
-        }
-        throw error;
-    }
-}

package/dist/issuance/approve.d.ts

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

package/dist/issuance/approve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../src/issuance/approve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AAkBH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAanE"}

package/dist/issuance/approve.js

@@ -1,36 +0,0 @@
-import { z } from "zod";
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-export const ApproveErc20RequestSchema = z.object({
-    tokenAddress: AddressSchema,
-    spender: AddressSchema,
-    amount: z.coerce.bigint().nonnegative(),
-});
-const approveRoute = describeRoute({
-    summary: "Approve Gated ERC20",
-    description: "Returns transaction data for approving spender to use a gated ERC20",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for approving a gated ERC20",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function approveErc20Token(factory) {
-    return factory.createHandlers(approveRoute, validator("json", ApproveErc20RequestSchema), async (c) => {
-        const { tokenAddress, spender, amount } = c.req.valid("json");
-        return c.json(toTransaction({
-            address: tokenAddress,
-            abi: erc20GatedAbi,
-            functionName: "approve",
-            args: [spender, BigInt(amount).toString()],
-        }));
-    });
-}