@evergonlabs/tmi-protocol-api 0.1.0

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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,91 @@
+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],
+        });
+    });
+}