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

package/dist/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, {
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    burnFrom: `0x${string}`;
-}, {
-    tokenAddress: `0x${string}`;
-    amount: bigint;
-    burnFrom: `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: {
-        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;
-            burnFrom: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            burnFrom: `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;
-            burnFrom: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            tokenAddress: `0x${string}`;
-            amount: bigint;
-            burnFrom: `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=burn.d.ts.map

package/dist/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/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 "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-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/issuance/common.d.ts

@@ -1,2 +0,0 @@
-export declare const GATING_SIGNER_ADDRESS: "0x29A75f22AC9A7303Abb86ce521Bb44C4C69028A0";
-//# sourceMappingURL=common.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/issuance/common.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,EAAG,4CAAqD,CAAC"}

package/dist/issuance/common.js

@@ -1 +0,0 @@
-export const GATING_SIGNER_ADDRESS = "0x29A75f22AC9A7303Abb86ce521Bb44C4C69028A0"; // @todo externalize

package/dist/issuance/deploy.d.ts

@@ -1,158 +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 function createErc721Token<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}`;
-    tokenName: string;
-    tokenSymbol: string;
-    defaultAdmin: `0x${string}`;
-    minter: `0x${string}`;
-}, {
-    cap: bigint;
-    erc20Address: `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[];
-    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}`;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            cap: bigint;
-            erc20Address: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${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}`;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            cap: bigint;
-            erc20Address: `0x${string}`;
-            tokenName: string;
-            tokenSymbol: string;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    args: any[];
-    bytecode: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-export declare const DeployTransparentUpgradeableProxySchema: z.ZodObject<{
-    implementation: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    proxyAdminOwner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    initData: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    initData: `0x${string}`;
-    implementation: `0x${string}`;
-    proxyAdminOwner: `0x${string}`;
-}, {
-    initData: `0x${string}`;
-    implementation: `0x${string}`;
-    proxyAdminOwner: `0x${string}`;
-}>;
-export declare function createTransparentUpgradeableProxy<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: {
-            initData: `0x${string}`;
-            implementation: `0x${string}`;
-            proxyAdminOwner: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            initData: `0x${string}`;
-            implementation: `0x${string}`;
-            proxyAdminOwner: `0x${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: {
-            initData: `0x${string}`;
-            implementation: `0x${string}`;
-            proxyAdminOwner: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            initData: `0x${string}`;
-            implementation: `0x${string}`;
-            proxyAdminOwner: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    abi: any[];
-    args: any[];
-    bytecode: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-export declare function createProxyAdmin<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">>>];
-//# sourceMappingURL=deploy.d.ts.map

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

package/dist/issuance/deploy.js

@@ -1,227 +0,0 @@
-import { z } from "zod";
-import { encodeFunctionData } from "viem";
-import { describeRoute } from "hono-openapi";
-import { erc1967ProxyAbi, erc1967ProxyBytecode } from "@evergonlabs/tmi-evm-contracts/erc1967";
-import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-protocol-contracts/transparentProxy";
-import { proxyAdminAbi, proxyAdminBytecode } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, HexStringSchema } from "../common/index.js";
-import { erc20GatedAbi, erc20GatedBytecode } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
-import { managedErc721Abi, managedErc721Bytecode } from "@evergonlabs/tmi-protocol-contracts/managedErc721";
-import { GATING_SIGNER_ADDRESS } from "./common.js";
-// Issue ERC20 Gated contract
-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,
-        });
-    });
-}
-// Issue ERC721 contract
-const IssuanceDeployErc721Schema = z
-    .object({
-    bytecode: HexStringSchema,
-    abi: z.array(z.any()).openapi({
-        description: "ABI of a contract.",
-        type: "array",
-    }),
-})
-    .openapi({ ref: "IssuanceDeployErc721Schema" });
-const deployErc721Route = describeRoute({
-    summary: "Get Upgradeable ERC721 Implementation",
-    description: `Returns bytecode and ABI for deploying an upgradeable ManagedERC721 implementation contract.
-
-This is an upgradeable contract that should be deployed behind a TransparentUpgradeableProxy:
-1. Deploy implementation using the returned bytecode
-2. Get init data via POST /issuance/erc721/getInitData
-3. Deploy ProxyAdmin via GET /issuance/proxy/deployProxyAdmin
-4. Deploy TransparentUpgradeableProxy via POST /issuance/proxy/deployTransparentProxy
-
-Features:
-- mint(to, tokenId) - Mint token (MINTER_ROLE gated)
-- burn(tokenId) - Burn token (owner, approved, or MINTER_ROLE)
-- setBaseURI(uri) - Set base URI (URI_SETTER_ROLE gated)
-- setTokenURI(tokenId, uri) - Set token-specific URI (URI_SETTER_ROLE gated)
-- setContractURI(uri) - Set contract metadata URI (URI_SETTER_ROLE gated)`,
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns bytecode and ABI for deploying an upgradeable ERC721 implementation",
-            content: {
-                "application/json": {
-                    schema: resolver(IssuanceDeployErc721Schema),
-                },
-            },
-        },
-    },
-});
-export function createErc721Token(factory) {
-    return factory.createHandlers(deployErc721Route, async (c) => {
-        return c.json({
-            bytecode: managedErc721Bytecode,
-            abi: managedErc721Abi,
-        });
-    });
-}
-// Issue ERC1967 proxy contract for ERC20 Gated
-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"],
-    deprecated: true,
-    responses: {
-        200: {
-            description: "Returns transaction data for deploying a ERC1967Proxy",
-            content: {
-                "application/json": {
-                    schema: resolver(IssuanceDeployErc1967Schema),
-                },
-            },
-        },
-    },
-});
-// @todo the same params are in getInitData.ts so it could be utilized
-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,
-});
-// @todo This must be splitted as we did with TUP
-// @todo make it deprecated
-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 initData = encodeFunctionData({
-            abi: erc20GatedAbi,
-            functionName: "init",
-            args: [tokenName, tokenSymbol, BigInt(cap), defaultAdmin, minter, GATING_SIGNER_ADDRESS],
-        });
-        return c.json({
-            bytecode: erc1967ProxyBytecode,
-            abi: erc1967ProxyAbi,
-            args: [erc20Address, initData],
-        });
-    });
-}
-// Issue generic TUP contract
-const IssuanceDeployTransparentProxySchema = 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 transparent proxy initialization",
-        type: "array",
-    }),
-})
-    .openapi({ ref: "IssuanceDeployTransparentProxySchema" });
-const deployTransparentProxyRoute = describeRoute({
-    summary: "Deploy TransparentUpgradeableProxy",
-    description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
-            content: {
-                "application/json": {
-                    schema: resolver(IssuanceDeployTransparentProxySchema),
-                },
-            },
-        },
-    },
-});
-export const DeployTransparentUpgradeableProxySchema = z.object({
-    implementation: AddressSchema.openapi("The address of the implementation contract"),
-    proxyAdminOwner: AddressSchema.openapi("The address of the proxy admin who is eligible to upgrade implementation"),
-    initData: HexStringSchema.openapi(`Encoded function call hex data for underlying implementation contract initialization. 
-    
-    Can be combined with "encodeFunctionData" of viem. 
-    NOTE: The underlying implementation contract must have initialization function.
-    `),
-});
-export function createTransparentUpgradeableProxy(factory) {
-    return factory.createHandlers(deployTransparentProxyRoute, validator("json", DeployTransparentUpgradeableProxySchema), async (c) => {
-        const { implementation, proxyAdminOwner, initData } = c.req.valid("json");
-        return c.json({
-            bytecode: transparentUpgradeableProxyBytecode,
-            abi: transparentUpgradeableProxyAbi,
-            args: [implementation, proxyAdminOwner, initData],
-        });
-    });
-}
-// Issue generic ProxyAdmin contract
-const IssuanceDeployProxyAdminSchema = z
-    .object({
-    bytecode: HexStringSchema.openapi({ description: "Bytecode of the smartcontract" }),
-    abi: z.array(z.any()).openapi({
-        description: "ABI of a contract.",
-        type: "array",
-    }),
-})
-    .openapi({ ref: "IssuanceDeployProxyAdminSchema" });
-const deployProxyAdminRoute = describeRoute({
-    summary: "Deploy ProxyAdmin",
-    description: "Returns transaction data for deploying a ProxyAdmin contract",
-    tags: ["Issuance"],
-    responses: {
-        200: {
-            description: "Returns transaction data for deploying a ProxyAdmin contract",
-            content: {
-                "application/json": {
-                    schema: resolver(IssuanceDeployProxyAdminSchema),
-                },
-            },
-        },
-    },
-});
-export function createProxyAdmin(factory) {
-    return factory.createHandlers(deployProxyAdminRoute, async (c) => {
-        return c.json({
-            bytecode: proxyAdminBytecode,
-            abi: proxyAdminAbi,
-        });
-    });
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB;;;;;;;iBAOnC,CAAC;AA2BH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAe3B,CAAC"}

package/dist/issuance/erc20/deployGated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployGated.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deployGated.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,6BAA6B;;;;;;;;iBAUxC,CAAC;AAoBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyBhC,CAAC"}

package/dist/issuance/erc20/getInitData.d.ts

@@ -1,59 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { z } from "zod";
-export declare const Erc20InitDataResponse: z.ZodObject<{
-    data: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-}, z.core.$strip>;
-export declare const Erc20InitDataParams: z.ZodObject<{
-    tokenName: z.ZodString;
-    tokenSymbol: z.ZodString;
-    cap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    defaultAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-}, z.core.$strip>;
-export declare function createGetErc20InitData<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            tokenName: string;
-            tokenSymbol: string;
-            cap: string;
-            defaultAdmin: string;
-            minter: string;
-        };
-    };
-    out: {
-        json: {
-            tokenName: string;
-            tokenSymbol: string;
-            cap: bigint;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `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: {
-            tokenName: string;
-            tokenSymbol: string;
-            cap: string;
-            defaultAdmin: string;
-            minter: string;
-        };
-    };
-    out: {
-        json: {
-            tokenName: string;
-            tokenSymbol: string;
-            cap: bigint;
-            defaultAdmin: `0x${string}`;
-            minter: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=getInitData.d.ts.map

package/dist/issuance/erc20/getInitData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/getInitData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,qBAAqB;;iBAIC,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;;;iBAQC,CAAC;AAkBlC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAaxE"}

package/dist/issuance/erc20/initialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,4BAA4B;;;;;;;;iBAUvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAc1B,CAAC"}

package/dist/issuance/erc20/parseErc20DeployEvent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseErc20DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/parseErc20DeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;QAoDhC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;;;iBAOpC,CAAC;AA2BH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}

package/dist/issuance/erc721/deployGated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deployGated.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/deployGated.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,8BAA8B;;;;;;;;iBAUzC,CAAC;AA4BH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBjC,CAAC"}

package/dist/issuance/erc721/getInitData.d.ts

@@ -1,49 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import z from "zod";
-export declare const Erc721InitDataResponse: z.ZodObject<{
-    data: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-}, z.core.$strip>;
-export declare const Erc721InitDataParams: z.ZodObject<{
-    tokenName: z.ZodString;
-    tokenSymbol: z.ZodString;
-    admin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-}, z.core.$strip>;
-export declare function createGetErc721InitData<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            tokenName: string;
-            tokenSymbol: string;
-            admin: string;
-        };
-    };
-    out: {
-        json: {
-            tokenName: string;
-            tokenSymbol: string;
-            admin: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `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: {
-            tokenName: string;
-            tokenSymbol: string;
-            admin: string;
-        };
-    };
-    out: {
-        json: {
-            tokenName: string;
-            tokenSymbol: string;
-            admin: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
-//# sourceMappingURL=getInitData.d.ts.map

package/dist/issuance/erc721/getInitData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/getInitData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,eAAO,MAAM,sBAAsB;;iBAIC,CAAC;AAErC,eAAO,MAAM,oBAAoB;;;;iBAQC,CAAC;AAqBnC,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAazE"}