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

package/dist/issuance/erc1155/gated/deploy.js

@@ -0,0 +1,62 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
+import { FactoryChainId, getFactories } from "../../common/factories.js";
+import { erc1155Tag } from "../tag.js";
+export const DeployGatedErc1155RequestSchema = z.object({
+    chainId: FactoryChainId.Schema,
+    baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
+    defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+    gatingSigner: AddressSchema.optional().openapi({
+        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
+    }),
+});
+const deployGatedErc1155Route = describeRoute({
+    summary: "Deploy Gated ERC1155 via Factory",
+    description: `This contract has not been audited.
+
+Returns transaction data for deploying a new gated ERC1155 token via the factory contract.
+
+Gated tokens require cryptographic signatures for transfers, mints, and burns.
+
+Calls deployAndInitializeProxy on the ERC1155AutoIdGatedPausableRecoverableFactory to atomic deploy and initialize a new token proxy.
+
+The deployed token supports:
+- mint(to, amount, data) - Mint tokens with auto-generated ID (MINTER_ROLE gated + signature required)
+- mintBatch(to, amounts, data) - Mint multiple tokens with auto-generated IDs (MINTER_ROLE gated + signature required)
+- burn(account, id, amount) - Burn tokens (signature required)
+- burnBatch(account, ids, amounts) - Burn multiple tokens (signature required)
+- setURI(newuri) - Set metadata URI (DEFAULT_ADMIN_ROLE gated)
+- pause() / unpause() - Pause/unpause transfers (PAUSER_ROLE gated)
+- recover(token, to, amount) - Recover tokens (RECOVER_ROLE gated)`,
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a gated ERC1155 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateGatedErc1155Token = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", deployGatedErc1155Route, validator("json", DeployGatedErc1155RequestSchema), async (c) => {
+        const { chainId, baseURI, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC1155AutoIdGatedPausableRecoverableFactory,
+            abi: abis.erc1155AutoIdGatedPausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [baseURI, defaultTokenAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
+        }));
+    }),
+});

package/dist/issuance/erc1155/gated/initialize.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const InitializeGatedErc1155RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    baseURI: z.ZodString;
+    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}`>>;
+    gatingSigner: z.ZodOptional<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 InitializeGatedErc1155: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    baseURI: string;
+                    defaultAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=initialize.d.ts.map

package/dist/issuance/erc1155/gated/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,mCAAmC;;;;;;iBAQ9C,CAAC;AAkBH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBjC,CAAC"}

package/dist/issuance/erc1155/gated/initialize.js

@@ -0,0 +1,45 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
+import { erc1155Tag } from "../tag.js";
+export const InitializeGatedErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
+    defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+    gatingSigner: AddressSchema.optional().openapi({
+        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
+    }),
+});
+const initializeRoute = describeRoute({
+    summary: "Initialize Gated ERC1155",
+    description: "Returns transaction data for initializing a gated ERC1155 token proxy contract",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for initializing a gated ERC1155 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const InitializeGatedErc1155 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", initializeRoute, validator("json", InitializeGatedErc1155RequestSchema), async (c) => {
+        const { tokenAddress, baseURI, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdWhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "initialize",
+            args: [baseURI, defaultAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
+        }));
+    }),
+});

package/dist/issuance/erc1155/gated/parseDeployEvent.d.ts

@@ -0,0 +1,21 @@
+export declare const ParseGatedErc1155DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                baseURI: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=parseDeployEvent.d.ts.map

package/dist/issuance/erc1155/gated/parseDeployEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/parseDeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;aAgDvC,CAAC"}

package/dist/issuance/erc1155/gated/parseDeployEvent.js

@@ -0,0 +1,75 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { parseEventLogs } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { createController } from "../../../common/controller.js";
+import { HttpError } from "../../../common/http-error.js";
+import { AddressSchema, HashSchema } from "../../../common/index.js";
+import { FactoryChainIdQuery } from "../../common/factories.js";
+import { erc1155Tag } from "../tag.js";
+const QuerySchema = z.object({
+    chainId: FactoryChainIdQuery.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    hash: HashSchema.openapi({
+        param: {
+            name: "hash",
+            in: "query",
+        },
+    }),
+});
+export const ParseGatedErc1155DeployEvent = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get Gated ERC1155 TokenProxyConfigured Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the Gated ERC1155 factory \`deployAndInitializeProxy\` action`,
+        tags: [erc1155Tag.tag],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            proxy: AddressSchema,
+                            admin: AddressSchema,
+                            minter: AddressSchema,
+                            baseURI: z.string(),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        const [event] = parseEventLogs({
+            abi: abis.erc1155AutoIdGatedPausableRecoverableFactoryAbi,
+            eventName: "TokenProxyConfigured",
+            logs: receipt.logs,
+        });
+        if (!event) {
+            throw new UnableParseGatedErc1155DeployEvent();
+        }
+        return c.json({
+            proxy: event.args.proxy,
+            admin: event.args.admin,
+            minter: event.args.minter,
+            baseURI: event.args.baseURI,
+        });
+    }),
+});
+class UnableParseGatedErc1155DeployEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the Gated ERC1155 factory \`deployAndInitializeProxy\` action`,
+            name: "UnableParseGatedErc1155DeployEvent",
+        });
+    }
+}

package/dist/issuance/erc1155/grantRole.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
+export declare const GrantRoleErc1155RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    role: z.ZodEnum<typeof Erc1155TokenRole>;
+    account: 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 GrantRoleErc1155: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: Erc1155TokenRole;
+                    account: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=grantRole.d.ts.map

package/dist/issuance/erc1155/grantRole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAiC,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAG5G,eAAO,MAAM,6BAA6B;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/issuance/erc1155/grantRole.js

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { convertErc1155TokenRoleToHash, Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
+import { erc1155Tag } from "./tag.js";
+export const GrantRoleErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    role: z.nativeEnum(Erc1155TokenRole).openapi({
+        description: "The role to grant",
+        example: Erc1155TokenRole.MINTER_ROLE,
+    }),
+    account: AddressSchema.openapi({ description: "The address to grant the role to" }),
+});
+const grantRoleRoute = describeRoute({
+    summary: "Grant Role on ERC1155",
+    description: "Returns transaction data for granting a role on the ERC1155 token contract",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for granting a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const GrantRoleErc1155 = createController({
+    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc1155RequestSchema), async (c) => {
+        const { tokenAddress, role, account } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdPausableRecoverableUpgradeableAbi,
+            functionName: "grantRole",
+            args: [convertErc1155TokenRoleToHash(role), account],
+        }));
+    }),
+});