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

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

@@ -1 +1 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}

package/dist/issuance/erc20/recover.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { Int256BigInt } from "../../common/int256.js";
+import { erc20Tag } from "./tag.js";
 export const RecoverErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover tokens from" }),
@@ -14,7 +15,7 @@ export const RecoverErc20RequestSchema = z.object({
 const recoverRoute = describeRoute({
     summary: "Recover Gated ERC20",
     description: "Returns transaction data for recovering a gated ERC20 token from one address to another (RECOVER_ROLE required)",
-    tags: ["Issuance"],
+    tags: [erc20Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for recovering a gated ERC20",

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

@@ -1 +1 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAG5F,eAAO,MAAM,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/renounceRole.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+import { erc20Tag } from "./tag.js";
 export const RenounceRoleErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc20GatedRole).openapi({
@@ -16,7 +17,7 @@ export const RenounceRoleErc20RequestSchema = z.object({
 const renounceRoleRoute = describeRoute({
     summary: "Renounce Role on Gated ERC20",
     description: "Returns transaction data for renouncing a role on a gated ERC20 token contract",
-    tags: ["Issuance"],
+    tags: [erc20Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for renouncing a role",

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

@@ -1 +1 @@
-{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}
+{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAG5F,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}

package/dist/issuance/erc20/revokeRole.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+import { erc20Tag } from "./tag.js";
 export const RevokeRoleErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc20GatedRole).openapi({
@@ -16,7 +17,7 @@ export const RevokeRoleErc20RequestSchema = z.object({
 const revokeRoleRoute = describeRoute({
     summary: "Revoke Role on Gated ERC20",
     description: "Returns transaction data for revoking a role on a gated ERC20 token contract",
-    tags: ["Issuance"],
+    tags: [erc20Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for revoking a role",

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

@@ -0,0 +1,4 @@
+export declare const erc20Tag: {
+    tag: "ERC20";
+};
+//# sourceMappingURL=tag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/tag.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;CAAqB,CAAC"}

package/dist/issuance/erc20/tag.js

@@ -0,0 +1,2 @@
+import { createTag } from "../../common/tag.js";
+export const erc20Tag = createTag("ERC20");

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

@@ -1 +1 @@
-{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transfer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transfer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc20/transfer.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { Int256BigInt } from "../../common/int256.js";
+import { erc20Tag } from "./tag.js";
 export const TransferErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema,
@@ -13,7 +14,7 @@ export const TransferErc20RequestSchema = z.object({
 const transferRoute = describeRoute({
     summary: "Transfer Gated ERC20",
     description: "Returns transaction data for transferring a gated ERC20 token to another address",
-    tags: ["Issuance"],
+    tags: [erc20Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for transferring a gated ERC20",

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

@@ -1 +1 @@
-{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/transferFrom.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { Int256BigInt } from "../../common/int256.js";
+import { erc20Tag } from "./tag.js";
 export const TransferFromErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to transfer tokens from" }),
@@ -14,7 +15,7 @@ export const TransferFromErc20RequestSchema = z.object({
 const transferFromRoute = describeRoute({
     summary: "TransferFrom Gated ERC20",
     description: "Returns transaction data for transferring a gated ERC20 token from one address to another (requires approval)",
-    tags: ["Issuance"],
+    tags: [erc20Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for transferring a gated ERC20",

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

@@ -1 +1 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/approve.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}
+{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/approve.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc721/approve.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { Int256BigInt } from "../../common/int256.js";
+import { erc721Tag } from "./tag.js";
 export const ApproveErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to approve" }),
@@ -13,7 +14,7 @@ export const ApproveErc721RequestSchema = z.object({
 const approveRoute = describeRoute({
     summary: "Approve ERC721",
     description: "Returns transaction data for approving an address to transfer a specific ERC721 token",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for approving an ERC721 token",
@@ -30,7 +31,7 @@ export const ApproveErc721 = createController({
         const { tokenAddress, to, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "approve",
             args: [to, BigInt(tokenId)],
         }));

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

@@ -1 +1 @@
-{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/burn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/burn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}

package/dist/issuance/erc721/burn.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { Int256BigInt } from "../../common/int256.js";
+import { erc721Tag } from "./tag.js";
 export const BurnErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     tokenId: Int256BigInt(z.bigint().nonnegative()),
@@ -12,7 +13,7 @@ export const BurnErc721RequestSchema = z.object({
 const burnRoute = describeRoute({
     summary: "Burn ERC721",
     description: "Returns transaction data for burning an ERC721 token",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for burning an ERC721 token",
@@ -29,7 +30,7 @@ export const BurnErc721 = createController({
         const { tokenAddress, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "burn",
             args: [BigInt(tokenId)],
         }));

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

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

package/dist/issuance/erc721/default/deploy.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { FactoryChainId, getFactories } from "../../common/factories.js";
+import { erc721Tag } from "../tag.js";
 export const DeployErc721RequestSchema = z.object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
@@ -19,15 +20,15 @@ const deployErc721Route = describeRoute({
 
 Returns transaction data for deploying a new ERC721 token via the factory contract.
 
-Calls deployAndInitializeProxy on the ERC721PausableRecoverableFactory to atomically deploy and initialize a new token proxy.
+Calls deployAndInitializeProxy on the ERC721AutoIdPausableRecoverableFactory to atomically deploy and initialize a new token proxy.
 
 The deployed token supports:
-- mint(to, tokenId) - Mint token (MINTER_ROLE gated)
+- mint(to) - Mint token with auto-generated ID (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"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for deploying an ERC721 token via factory",
@@ -44,8 +45,8 @@ export const CreateErc721Token = createController({
         const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({
-            address: factory.ERC721PausableRecoverableFactory,
-            abi: abis.erc721PausableRecoverableFactoryAbi,
+            address: factory.ERC721AutoIdPausableRecoverableFactory,
+            abi: abis.erc721AutoIdPausableRecoverableFactoryAbi,
             functionName: "deployAndInitializeProxy",
             args: [tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter],
         }));

package/dist/issuance/erc721/default/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,6BAA6B;;;;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAclC,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,6BAA6B;;;;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAclC,CAAC"}

package/dist/issuance/erc721/default/initialize.js

@@ -4,6 +4,7 @@ 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 { erc721Tag } from "../tag.js";
 export const InitializeErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
@@ -15,7 +16,7 @@ export const InitializeErc721RequestSchema = z.object({
 const initializeRoute = describeRoute({
     summary: "Initialize ERC721",
     description: "Returns transaction data for initializing an ERC721 token proxy contract",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for initializing an ERC721 token",
@@ -32,7 +33,7 @@ export const InitializeDefaultErc721 = createController({
         const { tokenAddress, name, symbol, baseURI, defaultAdmin, minter } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "initialize",
             args: [name, symbol, baseURI, defaultAdmin, minter],
         }));

package/dist/issuance/erc721/default/parseDeployEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/parseDeployEvent.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;aAoDxC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/parseDeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;aAoDxC,CAAC"}

package/dist/issuance/erc721/default/parseDeployEvent.js

@@ -9,6 +9,7 @@ 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 { erc721Tag } from "../tag.js";
 const QuerySchema = z.object({
     chainId: FactoryChainIdQuery.openapi({
         param: {
@@ -27,7 +28,7 @@ export const ParseDefaultErc721DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get ERC721 TokenProxyConfigured Event",
         description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the ERC721 factory \`deployAndInitializeProxy\` action`,
-        tags: ["Issuance"],
+        tags: [erc721Tag.tag],
         responses: {
             200: {
                 description: "Returns parsed event log",
@@ -51,7 +52,7 @@ export const ParseDefaultErc721DeployEvent = createController({
             hash: params.hash,
         });
         const [event] = parseEventLogs({
-            abi: abis.erc721PausableRecoverableFactoryAbi,
+            abi: abis.erc721AutoIdPausableRecoverableFactoryAbi,
             eventName: "TokenProxyConfigured",
             logs: receipt.logs,
         });

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

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

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

@@ -6,6 +6,7 @@ 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 { erc721Tag } from "../tag.js";
 export const DeployGatedErc721RequestSchema = z.object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
@@ -23,16 +24,16 @@ const deployGatedErc721Route = describeRoute({
 
 Returns transaction data for deploying a new gated ERC721 token via the factory contract.
 
-Calls deployAndInitializeProxy on the ERC721GatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy with whitelist gating.
+Calls deployAndInitializeProxy on the ERC721AutoIdGatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy with whitelist gating.
 
 The deployed token supports:
-- mint(to, tokenId) - Mint token (MINTER_ROLE gated)
+- mint(to) - Mint token with auto-generated ID (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)
 - Whitelist gating via gatingSigner for transfer verification`,
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for deploying a gated ERC721 token via factory",
@@ -51,8 +52,8 @@ export const CreateGatedErc721Token = createController({
         const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({
-            address: factory.ERC721GatedPausableRecoverableFactory,
-            abi: abis.erc721GatedPausableRecoverableFactoryAbi,
+            address: factory.ERC721AutoIdGatedPausableRecoverableFactory,
+            abi: abis.erc721AutoIdGatedPausableRecoverableFactoryAbi,
             functionName: "deployAndInitializeProxy",
             args: [tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
         }));

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

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,kCAAkC;;;;;;;;iBAU7C,CAAC;AAkBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAchC,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,kCAAkC;;;;;;;;iBAU7C,CAAC;AAkBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAchC,CAAC"}

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

@@ -5,6 +5,7 @@ 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 { erc721Tag } from "../tag.js";
 export const InitializeGatedErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
@@ -19,7 +20,7 @@ export const InitializeGatedErc721RequestSchema = z.object({
 const initializeRoute = describeRoute({
     summary: "Initialize Gated ERC721",
     description: "Returns transaction data for initializing a gated ERC721 token proxy contract",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for initializing a gated ERC721 token",
@@ -36,7 +37,7 @@ export const InitializeGatedErc721 = createController({
         const { tokenAddress, name, symbol, baseURI, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721WhitelistGatedPausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdWhitelistGatedPausableRecoverableUpgradeableAbi,
             functionName: "initialize",
             args: [name, symbol, baseURI, defaultAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
         }));

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/parseDeployEvent.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;aAoDtC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/parseDeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;aAoDtC,CAAC"}

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

@@ -9,6 +9,7 @@ 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 { erc721Tag } from "../tag.js";
 const QuerySchema = z.object({
     chainId: FactoryChainIdQuery.openapi({
         param: {
@@ -27,7 +28,7 @@ export const ParseGatedErc721DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get Gated ERC721 TokenProxyConfigured Event",
         description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the Gated ERC721 factory \`deployAndInitializeProxy\` action`,
-        tags: ["Issuance"],
+        tags: [erc721Tag.tag],
         responses: {
             200: {
                 description: "Returns parsed event log",
@@ -51,7 +52,7 @@ export const ParseGatedErc721DeployEvent = createController({
             hash: params.hash,
         });
         const [event] = parseEventLogs({
-            abi: abis.erc721GatedPausableRecoverableFactoryAbi,
+            abi: abis.erc721AutoIdGatedPausableRecoverableFactoryAbi,
             eventName: "TokenProxyConfigured",
             logs: receipt.logs,
         });

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

@@ -1 +1 @@
-{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAE3G,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAG3G,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}

package/dist/issuance/erc721/grantRole.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+import { erc721Tag } from "./tag.js";
 export const GrantRoleErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc721TokenRole).openapi({
@@ -16,7 +17,7 @@ export const GrantRoleErc721RequestSchema = z.object({
 const grantRoleRoute = describeRoute({
     summary: "Grant Role on ERC721",
     description: "Returns transaction data for granting a role on the ERC721 token contract",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for granting a role",
@@ -33,7 +34,7 @@ export const GrantRoleErc721 = createController({
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "grantRole",
             args: [convertErc721TokenRoleToHash(role), account],
         }));

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

@@ -204,7 +204,6 @@ export declare const Erc721Controller: import("../../common/controller.js").ICon
                 json: {
                     tokenAddress: string;
                     to: string;
-                    tokenId: string;
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/index.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAuB3B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/index.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAuB3B,CAAC"}

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

@@ -2,7 +2,6 @@ import { z } from "zod";
 export declare const MintErc721RequestSchema: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    tokenId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
 }, z.core.$strip>;
 export declare const MintErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
@@ -11,7 +10,6 @@ export declare const MintErc721: import("../../common/controller.js").IControlle
                 json: {
                     tokenAddress: string;
                     to: string;
-                    tokenId: string;
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAmBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}

package/dist/issuance/erc721/mint.js

@@ -4,16 +4,15 @@ 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 { Int256BigInt } from "../../common/int256.js";
+import { erc721Tag } from "./tag.js";
 export const MintErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to mint the token to" }),
-    tokenId: Int256BigInt(z.bigint().nonnegative()),
 });
 const mintRoute = describeRoute({
     summary: "Mint ERC721",
-    description: "Returns transaction data for minting an ERC721 token (MINTER_ROLE required)",
-    tags: ["Issuance"],
+    description: "Returns transaction data for minting an ERC721 token with an auto-generated token ID (MINTER_ROLE required)",
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for minting an ERC721 token",
@@ -27,12 +26,12 @@ const mintRoute = describeRoute({
 });
 export const MintErc721 = createController({
     build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc721RequestSchema), async (c) => {
-        const { tokenAddress, to, tokenId } = c.req.valid("json");
+        const { tokenAddress, to } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "mint",
-            args: [to, BigInt(tokenId)],
+            args: [to],
         }));
     }),
 });

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

@@ -0,0 +1,19 @@
+export declare const NextTokenIdErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    tokenAddress: string | string[];
+                };
+            };
+            output: {
+                nextTokenId: string;
+                totalMinted: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=nextTokenId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nextTokenId.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/nextTokenId.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;aAsD5B,CAAC"}

package/dist/issuance/erc721/nextTokenId.js

@@ -0,0 +1,79 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { zeroAddress } from "viem";
+import { getContractEvents } 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 { AddressSchema } from "../../common/index.js";
+import { FactoryChainIdQuery } from "../common/factories.js";
+const QuerySchema = z.object({
+    chainId: FactoryChainIdQuery.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    tokenAddress: AddressSchema.openapi({
+        param: {
+            name: "tokenAddress",
+            in: "query",
+        },
+        description: "ERC721 contract address",
+    }),
+});
+const ResponseSchema = z.object({
+    nextTokenId: z.string().openapi({
+        description: "Next available token ID (max minted tokenId + 1, or '0' if none minted)",
+        example: "42",
+    }),
+    totalMinted: z.number().int().nonnegative().openapi({
+        description: "Total number of tokens minted (Transfer events from address(0))",
+        example: 41,
+    }),
+});
+export const NextTokenIdErc721 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get next ERC721 token ID",
+        description: "Scans all Transfer events from address(0) (mints) for the given ERC721 contract and returns the next available token ID (highest minted ID + 1). If no tokens have been minted, returns '0'.",
+        tags: ["Issuance"],
+        responses: {
+            200: {
+                description: "Returns the next token ID and total minted count",
+                content: {
+                    "application/json": {
+                        schema: resolver(ResponseSchema),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const client = getPublicClient(params.chainId, c.env.config);
+        const mintEvents = await getContractEvents(client, {
+            address: params.tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            eventName: "Transfer",
+            args: {
+                from: zeroAddress,
+            },
+            fromBlock: "earliest",
+            toBlock: "latest",
+        });
+        if (mintEvents.length === 0) {
+            return c.json({
+                nextTokenId: "0",
+                totalMinted: 0,
+            });
+        }
+        const maxTokenId = mintEvents.reduce((max, event) => {
+            const tokenId = event.args.tokenId;
+            return tokenId > max ? tokenId : max;
+        }, 0n);
+        return c.json({
+            nextTokenId: (maxTokenId + 1n).toString(),
+            totalMinted: mintEvents.length,
+        });
+    }),
+});