@evergonlabs/tmi-protocol-api 0.8.1 → 0.10.0-rc.0

package/dist/src/general/index.d.ts

@@ -1,100 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare const generalApis: {
-    name: string;
-    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/estimateGas": {
-            $post: {
-                input: {
-                    json: {
-                        data: `0x${string}`;
-                        to: `0x${string}`;
-                        chainId: "11155111" | "31337";
-                        from: `0x${string}`;
-                    };
-                };
-                output: {
-                    readonly success: true;
-                    readonly value: string;
-                };
-                outputFormat: "json";
-                status: 200;
-            };
-        };
-    } & {
-        "/balance": {
-            $get: {
-                input: {
-                    query: {
-                        address: string | string[];
-                        chainId: string | string[];
-                        contract: string | string[];
-                    };
-                };
-                output: {
-                    address: `0x${string}`;
-                    balance: string;
-                };
-                outputFormat: "json";
-                status: import("hono/utils/http-status").ContentfulStatusCode;
-            };
-        };
-    } & {
-        "/balances": {
-            $post: {
-                input: {
-                    json: {
-                        address: `0x${string}`;
-                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                        contracts: `0x${string}`[];
-                    };
-                };
-                output: {
-                    quantityIn: string;
-                    quantityOut: string;
-                    name: string | null;
-                    symbol: string | null;
-                    decimals: string | null;
-                    address: string;
-                    totalBalance: string;
-                }[];
-                outputFormat: "json";
-                status: 200;
-            };
-        };
-    } & {
-        "/searchBalances": {
-            $post: {
-                input: {
-                    json: {
-                        address: `0x${string}`;
-                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                        page?: number | undefined;
-                        perPage?: number | undefined;
-                    };
-                };
-                output: {
-                    balances: {
-                        tokenAddress: `0x${string}`;
-                        balance: never;
-                        decimals: number | undefined;
-                        symbol: string;
-                        name: string;
-                        tokenId: undefined;
-                        type: "ERC-20" | "ERC-721" | "ERC-1155";
-                    }[];
-                    totalItems: number;
-                    totalPages: number;
-                    pageNumber: number;
-                };
-                outputFormat: "json";
-                status: 200;
-            };
-        };
-    }, "/general">, "/">;
-    config: {
-        title: string;
-        description: string;
-    };
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/src/general/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/general/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,eAAO,MAAM,WAAW;;gBAEV,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc/C,CAAC"}

package/dist/src/general/index.js

@@ -1,20 +0,0 @@
-import { createApiConfig } from "../common/app.js";
-import { createEstimateGasHandlersV0 } from "./estimateGas.js";
-import { createTag } from "../common/tag.js";
-import { createSearchBalancesV0 } from "./searchBalances.js";
-import { createGetBalanceV0 } from "./getBalance.js";
-import { createGetBalancesBatchV0 } from "./getBalancesBatch.js";
-const tag = createTag("General");
-export const generalApis = {
-    name: "General APIs",
-    createApp: (factory) => factory.createApp().route("/general", factory
-        .createApp()
-        .post("/estimateGas", ...createEstimateGasHandlersV0(factory, tag))
-        .get("/balance", ...createGetBalanceV0(factory, tag))
-        .post("/balances", ...createGetBalancesBatchV0(factory, tag))
-        .post("/searchBalances", ...createSearchBalancesV0(factory, tag))),
-    config: createApiConfig({
-        title: "General API",
-        description: "Utility APIs",
-    }),
-};

package/dist/src/general/searchBalances.d.ts

@@ -1,78 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITag } from "../common/tag.js";
-export declare function createSearchBalancesV0<E extends Env, TTag extends ITag>(factory: Factory<E>, tag: TTag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    balances: {
-        tokenAddress: `0x${string}`;
-        balance: never;
-        decimals: number | undefined;
-        symbol: string;
-        name: string;
-        tokenId: undefined;
-        type: "ERC-20" | "ERC-721" | "ERC-1155";
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            address: `0x${string}`;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            page?: number | undefined;
-            perPage?: number | undefined;
-        };
-    };
-    out: {
-        json: {
-            address: `0x${string}`;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            page?: number | undefined;
-            perPage?: number | undefined;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    balances: {
-        tokenAddress: `0x${string}`;
-        balance: never;
-        decimals: number | undefined;
-        symbol: string;
-        name: string;
-        tokenId: undefined;
-        type: "ERC-20" | "ERC-721" | "ERC-1155";
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            address: `0x${string}`;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            page?: number | undefined;
-            perPage?: number | undefined;
-        };
-    };
-    out: {
-        json: {
-            address: `0x${string}`;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            page?: number | undefined;
-            perPage?: number | undefined;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    balances: {
-        tokenAddress: `0x${string}`;
-        balance: never;
-        decimals: number | undefined;
-        symbol: string;
-        name: string;
-        tokenId: undefined;
-        type: "ERC-20" | "ERC-721" | "ERC-1155";
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, 200, "json">>>];
-//# sourceMappingURL=searchBalances.d.ts.map

package/dist/src/general/searchBalances.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchBalances.d.ts","sourceRoot":"","sources":["../../../src/general/searchBalances.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAIxC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDtG"}

package/dist/src/general/searchBalances.js

@@ -1,49 +0,0 @@
-import { z } from "zod";
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, TmiChainIdSchema } from "../common/index.js";
-import { BalancesResponseSchema } from "./common.js";
-import { getTokenBalance } from "./balance-client.js";
-export function createSearchBalancesV0(factory, tag) {
-    return factory.createHandlers(describeRoute({
-        summary: "Search balances",
-        description: "Returns ERC20 balances of a wallet",
-        tags: [tag.tag],
-        responses: {
-            200: {
-                description: "Returns ERC20 balances of a wallet",
-                content: {
-                    "application/json": {
-                        schema: resolver(BalancesResponseSchema),
-                    },
-                },
-            },
-        },
-    }), validator("json", z.object({
-        chainId: TmiChainIdSchema,
-        address: AddressSchema.openapi({
-            description: "The address to get the balance for.",
-        }),
-        page: z.optional(z.number()),
-        perPage: z.optional(z.number()),
-    })), async (c) => {
-        const { chainId, address } = c.req.valid("json");
-        const result = await getTokenBalance(address, chainId);
-        return c.json({
-            balances: result.map((it) => {
-                return {
-                    tokenAddress: it.contractAddress,
-                    balance: it.balance,
-                    decimals: it.decimals,
-                    symbol: it.symbol,
-                    name: it.name,
-                    tokenId: it.id,
-                    type: it.type,
-                };
-            }),
-            totalItems: result.length,
-            totalPages: 1,
-            pageNumber: 1,
-        }, 200);
-    });
-}

package/dist/src/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, {
-    amount: bigint;
-    spender: `0x${string}`;
-    tokenAddress: `0x${string}`;
-}, {
-    amount: bigint;
-    spender: `0x${string}`;
-    tokenAddress: `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: {
-        functionName: string;
-        address: `0x${string}`;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            amount: bigint;
-            spender: `0x${string}`;
-            tokenAddress: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            amount: bigint;
-            spender: `0x${string}`;
-            tokenAddress: `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: {
-            amount: bigint;
-            spender: `0x${string}`;
-            tokenAddress: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            amount: bigint;
-            spender: `0x${string}`;
-            tokenAddress: `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=approve.d.ts.map

package/dist/src/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/src/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 "../common/abis/erc20Whitelisted.js";
-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()],
-        }));
-    });
-}

package/dist/src/issuance/burn.d.ts

@@ -1,75 +0,0 @@
-import { z } from "zod";
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare const BurnErc20RequestSchema: z.ZodObject<{
-    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    amount: z.ZodBigInt;
-    burnFrom: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    amount: bigint;
-    burnFrom: `0x${string}`;
-    tokenAddress: `0x${string}`;
-}, {
-    amount: bigint;
-    burnFrom: `0x${string}`;
-    tokenAddress: `0x${string}`;
-}>;
-export declare function burnErc20Token<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: {
-            amount: bigint;
-            burnFrom: `0x${string}`;
-            tokenAddress: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            amount: bigint;
-            burnFrom: `0x${string}`;
-            tokenAddress: `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: {
-            amount: bigint;
-            burnFrom: `0x${string}`;
-            tokenAddress: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            amount: bigint;
-            burnFrom: `0x${string}`;
-            tokenAddress: `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=burn.d.ts.map

package/dist/src/issuance/burn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/burn.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,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAkBH,wBAAgB,cAAc,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAahE"}

package/dist/src/issuance/burn.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 "../common/abis/erc20Whitelisted.js";
-export const BurnErc20RequestSchema = z.object({
-    tokenAddress: AddressSchema,
-    amount: z.coerce.bigint().nonnegative(),
-    burnFrom: AddressSchema,
-});
-const burnRoute = describeRoute({
-    summary: "Burn Gated ERC20",
-    description: "Returns transaction data for burning a gated ERC20",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for burning a gated ERC20",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function burnErc20Token(factory) {
-    return factory.createHandlers(burnRoute, validator("json", BurnErc20RequestSchema), async (c) => {
-        const { tokenAddress, amount, burnFrom } = c.req.valid("json");
-        return c.json(toTransaction({
-            address: tokenAddress,
-            abi: erc20GatedAbi,
-            functionName: "burnFrom",
-            args: [burnFrom, BigInt(amount).toString()],
-        }));
-    });
-}

package/dist/src/issuance/deploy.d.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createErc20Token<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    bytecode: `0x${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, {}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    bytecode: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-export declare const DeployErc1967ProxySchema: z.ZodObject<{
-    erc20Address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    tokenName: z.ZodString;
-    tokenSymbol: z.ZodString;
-    cap: z.ZodBigInt;
-    defaultAdmin: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    minter: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    cap: bigint;
-    erc20Address: `0x${string}`;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
-    tokenName: string;
-    tokenSymbol: string;
-}, {
-    cap: bigint;
-    erc20Address: `0x${string}`;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
-    tokenName: string;
-    tokenSymbol: string;
-}>;
-export declare function createErc1967Proxy<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    args: any[];
-    bytecode: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            cap: bigint;
-            erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-    out: {
-        json: {
-            cap: bigint;
-            erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    args: any[];
-    bytecode: `0x${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: {
-            cap: bigint;
-            erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-    out: {
-        json: {
-            cap: bigint;
-            erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    args: any[];
-    bytecode: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=deploy.d.ts.map

package/dist/src/issuance/deploy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA+BvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE;AAgCD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAiBpE"}

package/dist/src/issuance/deploy.js

@@ -1,91 +0,0 @@
-import { z } from "zod";
-import { describeRoute } from "hono-openapi";
-import { erc1967ProxyAbi, erc1967ProxyBytecode } from "@evergonlabs/tmi-evm-contracts/erc1967";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, HexStringSchema } from "../common/index.js";
-import { encodeFunctionData } from "viem";
-import { erc20GatedAbi, erc20GatedBytecode } from "../common/abis/erc20Whitelisted.js";
-const IssuanceDeployErc20Schema = z
-    .object({
-    bytecode: HexStringSchema,
-    abi: z.array(z.any()).openapi({
-        description: "ABI of a contract.",
-        type: "array",
-    }),
-})
-    .openapi({ ref: "IssuanceDeployErc20Schema" });
-const deployRoute = describeRoute({
-    summary: "Get Gated ERC20",
-    description: "Returns transaction data for deploying a gated ERC20",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for deploying a gated ERC20",
-            content: {
-                "application/json": {
-                    schema: resolver(IssuanceDeployErc20Schema),
-                },
-            },
-        },
-    },
-});
-export function createErc20Token(factory) {
-    return factory.createHandlers(deployRoute, async (c) => {
-        return c.json({
-            bytecode: erc20GatedBytecode,
-            abi: erc20GatedAbi,
-        });
-    });
-}
-const IssuanceDeployErc1967Schema = z
-    .object({
-    bytecode: HexStringSchema.openapi({ description: "Bytecode of the smartcontract" }),
-    abi: z.array(z.any()).openapi({
-        description: "ABI of a contract.",
-        type: "array",
-    }),
-    args: z.array(z.any()).openapi({
-        description: "Arguments for the proxy initialization",
-        type: "array",
-    }),
-})
-    .openapi({ ref: "IssuanceDeployErc1967Schema" });
-const deployProxyRoute = describeRoute({
-    summary: "Get ERC1967Proxy",
-    description: "Returns transaction data for deploying a ERC1967Proxy",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for deploying a ERC1967Proxy",
-            content: {
-                "application/json": {
-                    schema: resolver(IssuanceDeployErc1967Schema),
-                },
-            },
-        },
-    },
-});
-export const DeployErc1967ProxySchema = z.object({
-    erc20Address: AddressSchema.openapi("The address of the deployed contract from `Get Gated ERC20`"),
-    tokenName: z.string(),
-    tokenSymbol: z.string(),
-    cap: z.coerce.bigint(),
-    defaultAdmin: AddressSchema,
-    minter: AddressSchema,
-});
-export function createErc1967Proxy(factory) {
-    return factory.createHandlers(deployProxyRoute, validator("json", DeployErc1967ProxySchema), async (c) => {
-        const { erc20Address, tokenName, tokenSymbol, cap, defaultAdmin, minter } = c.req.valid("json");
-        const gatingSigner = "0x29A75f22AC9A7303Abb86ce521Bb44C4C69028A0"; // todo: externalize
-        const initData = encodeFunctionData({
-            abi: erc20GatedAbi,
-            functionName: "init",
-            args: [tokenName, tokenSymbol, BigInt(cap), defaultAdmin, minter, gatingSigner],
-        });
-        return c.json({
-            bytecode: erc1967ProxyBytecode,
-            abi: erc1967ProxyAbi,
-            args: [erc20Address, initData],
-        });
-    });
-}