@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/general/index.js

@@ -1,20 +1,15 @@
-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
+import { createApi } from "../common/controller.js";
+import { EstimateGasV0 } from "./estimateGas.js";
+import { GetBalanceV0 } from "./getBalance.js";
+import { GetBalancesBatchV0 } from "./getBalancesBatch.js";
+import { SearchBalancesV0 } from "./searchBalances.js";
+export const GeneralApi = createApi({
+    title: "General API",
+    description: "Utility APIs",
+    build: (factory) => 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",
-    }),
-};
+        .route("/estimateGas", EstimateGasV0.build(factory))
+        .route("/balance", GetBalanceV0.build(factory))
+        .route("/balances", GetBalancesBatchV0.build(factory))
+        .route("/searchBalances", SearchBalancesV0.build(factory)),
+});

package/dist/general/searchBalances.d.ts

@@ -1,70 +1,30 @@
-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: string;
-        decimals: number;
-        symbol: string;
-        name: string;
-        tokenId: string | null;
-        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
+import { z } from "zod";
+export declare const SearchBalancesV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    address: string;
+                };
+            };
+            output: {
+                balances: {
+                    tokenAddress: `0x${string}`;
+                    balance: string & z.core.$brand<"Int256">;
+                    decimals: number;
+                    symbol: string;
+                    name: string;
+                    tokenId: (string & z.core.$brand<"Int256">) | null;
+                    type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
+                }[];
+                totalItems: number;
+                totalPages: number;
+                pageNumber: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-    out: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    balances: {
-        tokenAddress: `0x${string}`;
-        balance: string;
-        decimals: number;
-        symbol: string;
-        name: string;
-        tokenId: string | null;
-        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, 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: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    balances: {
-        tokenAddress: `0x${string}`;
-        balance: string;
-        decimals: number;
-        symbol: string;
-        name: string;
-        tokenId: string | null;
-        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+}, "/">>;
 //# sourceMappingURL=searchBalances.d.ts.map

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA8CtG"}
+{"version":3,"file":"searchBalances.d.ts","sourceRoot":"","sources":["../../src/general/searchBalances.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyBxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkC3B,CAAC"}

package/dist/general/searchBalances.js

@@ -1,32 +1,36 @@
-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 { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { createController } from "../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../common/index.js";
+import { createTag } from "../common/tag.js";
 import { getAccountBalances } from "./balanceClient.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),
-                    },
+import { BalancesResponseSchema } from "./common.js";
+const tag = createTag("General");
+const searchBalancesRoute = 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,
+    },
+});
+export const SearchBalancesV0 = createController({
+    build: (factory) => factory.createApp().post("/", searchBalancesRoute, validator("json", z.object({
+        chainId: FractionsChainId,
         address: AddressSchema.openapi({
             description: "The address to get the balance for.",
         }),
     })), async (c) => {
         const { chainId, address } = c.req.valid("json");
-        const result = await getAccountBalances(address, chainId);
+        const result = await getAccountBalances(address, chainId, c.env.config);
         return c.json({
             balances: result.map((x) => ({
                 tokenAddress: x.tokenAddress,
@@ -41,5 +45,5 @@ export function createSearchBalancesV0(factory, tag) {
             totalPages: 1,
             pageNumber: 1,
         });
-    });
-}
+    }),
+});

package/dist/general/utils/tokenBalance/tokenBalance.d.ts

@@ -1,44 +1,28 @@
+import { z } from "zod";
 import { TokenTypeEnum } from "@evergonlabs/tmi-protocol-types/evm";
-import { z } from "../../../common/zod.js";
-export declare const TokenBalance: z.ZodEffects<z.ZodObject<{
-    balance: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>;
-    contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    decimals: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodNumber>, number, string | number | bigint>;
-    tokenId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>>;
+export declare const TokenBalance: z.ZodPipe<z.ZodObject<{
+    balance: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    decimals: z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<number, number>>;
+    tokenId: z.ZodOptional<z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<string & z.core.$brand<"Int256">, number>>>;
     name: z.ZodString;
     symbol: z.ZodString;
-    type: z.ZodEffects<z.ZodString, TokenTypeEnum | null, string>;
-}, "strip", z.ZodTypeAny, {
-    symbol: string;
-    type: TokenTypeEnum | null;
-    contractAddress: `0x${string}`;
-    name: string;
+    type: z.ZodPipe<z.ZodString, z.ZodTransform<TokenTypeEnum | null, string>>;
+}, z.core.$strip>, z.ZodTransform<{
+    tokenAddress: `0x${string}`;
+    balance: string & z.core.$brand<"Int256">;
     decimals: number;
-    balance: string;
-    tokenId?: string | undefined;
-}, {
-    symbol: string;
-    type: string;
-    contractAddress: `0x${string}`;
     name: string;
-    decimals: string | number | bigint;
-    balance: string | number | bigint;
-    tokenId?: string | number | bigint | undefined;
-}>, {
-    tokenAddress: `0x${string}`;
     symbol: string;
     type: TokenTypeEnum | null;
-    name: string;
-    decimals: number;
-    balance: string;
-    tokenId?: string | undefined;
+    tokenId?: (string & z.core.$brand<"Int256">) | undefined;
 }, {
-    symbol: string;
-    type: string;
+    balance: string & z.core.$brand<"Int256">;
     contractAddress: `0x${string}`;
+    decimals: number;
     name: string;
-    decimals: string | number | bigint;
-    balance: string | number | bigint;
-    tokenId?: string | number | bigint | undefined;
-}>;
+    symbol: string;
+    type: TokenTypeEnum | null;
+    tokenId?: (string & z.core.$brand<"Int256">) | undefined;
+}>>;
 //# sourceMappingURL=tokenBalance.d.ts.map

package/dist/general/utils/tokenBalance/tokenBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokenBalance.d.ts","sourceRoot":"","sources":["../../../../src/general/utils/tokenBalance/tokenBalance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAW3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcpB,CAAC"}
+{"version":3,"file":"tokenBalance.d.ts","sourceRoot":"","sources":["../../../../src/general/utils/tokenBalance/tokenBalance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAYpE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;GAcpB,CAAC"}

package/dist/general/utils/tokenBalance/tokenBalance.js

@@ -1,7 +1,7 @@
+import { z } from "zod";
 import { TokenTypeEnum } from "@evergonlabs/tmi-protocol-types/evm";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { AddressSchema } from "../../../common/index.js";
-import { z } from "../../../common/zod.js";
-import { NumberishSchema } from "@evergonlabs/tmi-protocol-types/common";
 const tokenTypeDict = {
     "ERC-721": TokenTypeEnum.ERC721,
     "ERC-1155": TokenTypeEnum.ERC1155,
@@ -10,11 +10,11 @@ const tokenTypeDict = {
 // @see definitions here https://docs.blockscout.com/devs/apis/rpc/account#get-list-of-tokens-owned-by-address
 export const TokenBalance = z
     .object({
-    balance: NumberishSchema.pipe(z.string()),
+    balance: Int256Json,
     contractAddress: AddressSchema,
     // ERC-721 and ERC-1155 has no decimals but for interoperability we return 1
-    decimals: NumberishSchema.pipe(z.coerce.number()).transform((x) => x || 1),
-    tokenId: z.optional(NumberishSchema.pipe(z.string())),
+    decimals: z.coerce.number().transform((x) => x || 1),
+    tokenId: z.coerce.number().transform(toInt256Json).optional(),
     name: z.string(),
     symbol: z.string(),
     type: z.string().transform((x) => (x in tokenTypeDict ? tokenTypeDict[x] : null)),

package/dist/issuance/approve.js

@@ -2,7 +2,7 @@ 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";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 export const ApproveErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     spender: AddressSchema,

package/dist/issuance/burn.js

@@ -2,7 +2,7 @@ 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";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 export const BurnErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     amount: z.coerce.bigint().nonnegative(),

package/dist/issuance/common/exports.d.ts

@@ -0,0 +1,2 @@
+export { FactoryChainId, type IFactoryChainId } from "./factories.js";
+//# sourceMappingURL=exports.d.ts.map

package/dist/issuance/common/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../../src/issuance/common/exports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/issuance/common/exports.js

@@ -0,0 +1 @@
+export { FactoryChainId } from "./factories.js";

package/dist/issuance/common/factories.d.ts

@@ -0,0 +1,167 @@
+export declare const FactoryChainId: {
+    Schema: import("zod").ZodUnion<[import("zod").ZodLiteral<11155111 | 72080>, import("zod").ZodLiteral<11155111 | 72080>, ...import("zod").ZodLiteral<11155111 | 72080>[]]>;
+    chains: ({
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://sepolia.etherscan.io";
+                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+            };
+        };
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 751532;
+            };
+            readonly ensRegistry: {
+                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+            };
+            readonly ensUniversalResolver: {
+                readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
+                readonly blockCreated: 5317080;
+            };
+        };
+        id: 11155111;
+        name: "Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.drpc.org"];
+            };
+        };
+        sourceId?: number | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    } | {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Nexera Blockscout";
+                readonly url: "https://explorer.testnet.nexera.network/";
+            };
+        };
+        contracts: {};
+        id: 72080;
+        name: "Nexera Testnet";
+        nativeCurrency: {
+            readonly decimals: 18;
+            readonly name: "Nexera";
+            readonly symbol: "tNXRA";
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.testnet.nexera.network"];
+            };
+            readonly public: {
+                readonly http: readonly ["https://rpc.testnet.nexera.network"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    })[];
+    chainIds: (11155111 | 72080)[];
+    isSupported: (chainId: number) => chainId is 11155111 | 72080;
+    get: <T extends 11155111 | 72080>(chainId: T) => Extract<{
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://sepolia.etherscan.io";
+                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+            };
+        };
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 751532;
+            };
+            readonly ensRegistry: {
+                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+            };
+            readonly ensUniversalResolver: {
+                readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
+                readonly blockCreated: 5317080;
+            };
+        };
+        id: 11155111;
+        name: "Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.drpc.org"];
+            };
+        };
+        sourceId?: number | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    }, {
+        id: T;
+    }> | Extract<{
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Nexera Blockscout";
+                readonly url: "https://explorer.testnet.nexera.network/";
+            };
+        };
+        contracts: {};
+        id: 72080;
+        name: "Nexera Testnet";
+        nativeCurrency: {
+            readonly decimals: 18;
+            readonly name: "Nexera";
+            readonly symbol: "tNXRA";
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.testnet.nexera.network"];
+            };
+            readonly public: {
+                readonly http: readonly ["https://rpc.testnet.nexera.network"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    }, {
+        id: T;
+    }>;
+};
+export declare const factoryChainIds: (11155111 | 72080)[];
+export type IFactoryChainId = (typeof factoryChainIds)[number];
+export declare function getFactories<T extends IFactoryChainId>(id: T): {
+    readonly DiamondFactory: "0x4be118d8a3a6f1490162e134E7419284827dbdBb";
+    readonly ERC1155GatedPausableRecoverableFactory: "0xe6727c1489F20a0b6d72A8D077BF14c7Ec495a94";
+    readonly ERC1155PausableRecoverableFactory: "0x14c2373FdE3a3dE21855376aF6420275cEB42320";
+    readonly ERC20GatedPausableRecoverableFactory: "0xee78B77c389770133573413A1606cA6db3941016";
+    readonly ERC20PausableRecoverableFactory: "0x2C81bb09947C16879f2a1C9380693FA628124515";
+    readonly ERC721GatedPausableRecoverableFactory: "0x04728c4C6130AB25844822F0ad940313daA5FF14";
+    readonly ERC721PausableRecoverableFactory: "0xA5048d05d8613db40C4eC0cFa08f9f1dCf916dDe";
+} | {
+    readonly DiamondFactory: "0x141c8f5BC8f7895E800518dc799f3D6e419b30Ac";
+    readonly ERC1155GatedPausableRecoverableFactory: "0xD21c194D6ac21A199223Aaa5d2b241a6f74117F0";
+    readonly ERC1155PausableRecoverableFactory: "0x5A981Bc93Bc434906C5DfbBb4B3fB7D0b8763854";
+    readonly ERC20GatedPausableRecoverableFactory: "0x12B91A2B8e99bf04C05885d71EB17d934d8c779d";
+    readonly ERC20PausableRecoverableFactory: "0xa66f033EB5C6D054cab1a2A41b39a1bDD9db2c16";
+    readonly ERC721GatedPausableRecoverableFactory: "0xd3b4B5f94f9E715987b5060a56C2575a56f5Bb08";
+    readonly ERC721PausableRecoverableFactory: "0xce97D17948bE18ef92490Da8AeB85c7ebC3c8694";
+};
+//# sourceMappingURL=factories.d.ts.map

package/dist/issuance/common/factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../../src/issuance/common/factories.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAY0S,MAAgB;;6BAAyF,MAAgB,qCAAqC,MAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA9K,MAAgB;;6BAAyF,MAAgB,qCAAqC,MAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAZta,CAAC;AAC9E,eAAO,MAAM,eAAe,sBAAmF,CAAC;AAChH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,wBAAgB,YAAY,CAAC,CAAC,SAAS,eAAe,EAAE,EAAE,EAAE,CAAC;;;;;;;;;;;;;;;;EAO5D"}

package/dist/issuance/common/factories.js

@@ -0,0 +1,15 @@
+import { sepolia } from "viem/chains";
+import { constants } from "@evergonlabs/tmi-factories-sdk";
+import { nexeraTestnet } from "@evergonlabs/tmi-protocol-types/evm";
+import { createSupportedChains } from "@evergonlabs/tmi-utils/models";
+import { HttpError } from "../../common/http-error.js";
+export const FactoryChainId = createSupportedChains([sepolia, nexeraTestnet]);
+export const factoryChainIds = FactoryChainId.chainIds;
+export function getFactories(id) {
+    if (id in constants.factoryAddresses) {
+        return constants.factoryAddresses[id];
+    }
+    throw new HttpError(400, {
+        message: "This chain id is not supported yet",
+    });
+}

package/dist/issuance/deploy.d.ts

@@ -25,17 +25,17 @@ export declare const DeployErc1967ProxySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     cap: bigint;
     erc20Address: `0x${string}`;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
     tokenName: string;
     tokenSymbol: string;
+    defaultAdmin: `0x${string}`;
+    minter: `0x${string}`;
 }, {
     cap: bigint;
     erc20Address: `0x${string}`;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
     tokenName: string;
     tokenSymbol: string;
+    defaultAdmin: `0x${string}`;
+    minter: `0x${string}`;
 }>;
 export declare function createErc1967Proxy<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
     abi: any[];
@@ -46,20 +46,20 @@ export declare function createErc1967Proxy<E extends Env>(factory: Factory<E>):
         json: {
             cap: bigint;
             erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
             tokenName: string;
             tokenSymbol: string;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
         };
     };
     out: {
         json: {
             cap: bigint;
             erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
             tokenName: string;
             tokenSymbol: string;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
@@ -71,20 +71,20 @@ export declare function createErc1967Proxy<E extends Env>(factory: Factory<E>):
         json: {
             cap: bigint;
             erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
             tokenName: string;
             tokenSymbol: string;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
         };
     };
     out: {
         json: {
             cap: bigint;
             erc20Address: `0x${string}`;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
             tokenName: string;
             tokenSymbol: string;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/issuance/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAkCvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE;AA8BD,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOnE;AAqCD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAKH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAgBpE;AAkCD,eAAO,MAAM,uCAAuC;;;;;;;;;;;;EASlD,CAAC;AAEH,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAcnF;AA8BD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/issuance/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAkCvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE;AA2CD,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOnE;AAqCD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAKH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAgBpE;AAkCD,eAAO,MAAM,uCAAuC;;;;;;;;;;;;EASlD,CAAC;AAEH,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAcnF;AA8BD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE"}