✨ Add NFT minting for asset objects

agmangas · agmangas · commit 935390db2fea · 2026-04-08T12:44:38.000+02:00
diff --git a/moderate_api/entities/asset/trust_routes.py b/moderate_api/entities/asset/trust_routes.py
@@ -20,6 +20,7 @@
     fetch_nft_metadata,
     fetch_verify_proof,
     get_verification_count_for_key,
+    mint_nft_task,
 )
 
 _logger = logging.getLogger(__name__)
@@ -38,6 +39,11 @@ class AssetObjectProofCreationResponse(BaseModel):
     obj: UploadedS3Object | None
 
 
+class MintNftRequest(BaseModel):
+    object_key_or_id: str | int
+    license: str
+
+
 async def _find_enforce_s3obj(
     object_key_or_id: str | int,
     session: AsyncSessionDep,
@@ -175,6 +181,54 @@ async def get_asset_nft_metadata(
         return None
 
 
+@router.post("/nft/mint", response_model=dict, tags=[_TAG])
+async def mint_asset_nft(
+    *,
+    user: UserDep,
+    session: AsyncSessionDep,
+    settings: SettingsDep,
+    background_tasks: BackgroundTasks,
+    body: MintNftRequest,
+):
+    """Initiate NFT minting for an asset object.
+
+    The object must already have a proof (proof_id set). Minting is restricted
+    to the asset owner or admin. The NFT is minted asynchronously; poll
+    GET /asset/proof/task/{task_id} for completion status.
+
+    Returns:
+        dict with task_id to poll.
+    """
+    if not settings.trust_service or not settings.trust_service.endpoint_url:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE)
+
+    s3object = await _find_enforce_s3obj(
+        object_key_or_id=body.object_key_or_id,
+        session=session,
+        user=user,
+        public_assets_allowed=False,
+    )
+
+    if not s3object.proof_id:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="A proof must exist before minting an NFT for this object.",
+        )
+
+    task_id = await init_task(session=session, username_owner=user.username)
+
+    background_tasks.add_task(
+        mint_nft_task,
+        task_id=str(task_id),
+        s3object_key_or_id=body.object_key_or_id,
+        requester_username=user.username,
+        license=body.license,
+        mint_nft_url=settings.trust_service.url_get_nfts(),
+    )
+
+    return {"task_id": task_id}
+
+
 @router.get(
     "/verification-count",
     response_model=VerificationCountItem | None,
diff --git a/moderate_api/trust.py b/moderate_api/trust.py
@@ -3,6 +3,7 @@
 import io
 import logging
 import pprint
+import re
 import time
 from collections import defaultdict
 from functools import wraps
@@ -165,6 +166,98 @@ async def create_proof_task(
         await set_task_result(session=session, task_id=task_id, result=result)
 
 
+@_handle_task_error
+async def mint_nft_task(
+    task_id: str,
+    s3object_key_or_id: str | int,
+    requester_username: str,
+    license: str,
+    mint_nft_url: str,
+    timeout_seconds: int = _TIMEOUT_SECS_HIGH,
+) -> None:
+    """Background task to mint an NFT for an asset object via the trust service.
+
+    Args:
+        task_id: Long-running task identifier for status tracking.
+        s3object_key_or_id: The S3 object key or database ID of the object to mint.
+        requester_username: The username of the user requesting the mint.
+        license: The license string to embed in the NFT (e.g. "CC-BY-4.0").
+        mint_nft_url: The trust service endpoint URL for NFT minting (POST /api/nfts).
+        timeout_seconds: HTTP request timeout in seconds.
+
+    Raises:
+        ValueError: If the object is not found, has no proof, or the owner has no DID.
+    """
+    async with with_session() as session:
+        s3obj = await find_s3object_by_key_or_id(
+            val=s3object_key_or_id, session=session
+        )
+
+        if not s3obj:
+            raise ValueError(f"Asset object '{s3object_key_or_id}' not found")
+
+        if not s3obj.proof_id:
+            raise ValueError(
+                f"Asset object '{s3object_key_or_id}' has no proof — "
+                "a proof must exist before minting an NFT"
+            )
+
+        # Resolve the DID from the asset owner (platform compensates for the Trust
+        # Service's unimplemented ownership check — the DID is never caller-supplied)
+        owner_username = (
+            s3obj.asset.username
+            if s3obj.asset and s3obj.asset.username
+            else requester_username
+        )
+
+        user_did = await get_did_for_username(username=owner_username, session=session)
+
+        if not user_did:
+            raise ValueError(
+                f"User '{owner_username}' does not have a DID and cannot mint an NFT"
+            )
+
+        # Auto-derive nftAlias: prefer explicit object name, then parent asset name,
+        # then fall back to the raw key. Sanitise to safe characters and truncate.
+        raw_alias = (
+            s3obj.name or (s3obj.asset.name if s3obj.asset else None) or s3obj.key
+        )
+        nft_alias = re.sub(r"[^a-zA-Z0-9 _\-]", "", raw_alias).strip()[:64] or "Asset"
+
+        # Auto-derive nftSymbol: first 6 uppercase alphanumeric chars of asset name.
+        # nftSymbol has no uniqueness or length constraint on the Trust Service side.
+        raw_symbol = re.sub(
+            r"[^a-zA-Z0-9]", "", s3obj.asset.name if s3obj.asset else ""
+        ).upper()[:6]
+        nft_symbol = raw_symbol or "ASSET"
+
+        async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+            json_payload = {
+                "assetId": s3obj.key,
+                "nftAlias": nft_alias,
+                "nftSymbol": nft_symbol,
+                "license": license,
+                "did": user_did,
+            }
+
+            _logger.info(
+                "Calling %s with payload:\n%s",
+                mint_nft_url,
+                pprint.pformat(json_payload),
+            )
+
+            resp = await client.post(mint_nft_url, json=json_payload)
+            resp.raise_for_status()
+
+        _logger.info("NFT minted successfully for object '%s'", s3object_key_or_id)
+
+        await set_task_result(
+            session=session,
+            task_id=task_id,
+            result={"status": "minted", "object_key": s3obj.key},
+        )
+
+
 class ProofResponse(BaseModel):
     metadata_digest: str
 
diff --git a/moderate_ui/src/api/assets.ts b/moderate_ui/src/api/assets.ts
@@ -389,6 +389,21 @@ export async function getAssetNftMetadata({
   return response.data ?? null;
 }
 
+export async function mintAssetNft({
+  objectKeyOrId,
+  license,
+}: {
+  objectKeyOrId: number | string;
+  license: string;
+}): Promise<{ task_id: number }> {
+  const url = buildApiUrl("asset", "nft", "mint");
+  const response = await axios.post(url, {
+    object_key_or_id: objectKeyOrId,
+    license,
+  });
+  return response.data;
+}
+
 export interface AssetObjectColumnsResponse {
   columns: string[];
 }
diff --git a/moderate_ui/src/pages/asset-objects/Show.tsx b/moderate_ui/src/pages/asset-objects/Show.tsx
@@ -7,9 +7,11 @@ import {
   Card,
   Group,
   LoadingOverlay,
+  Modal,
   Stack,
   Tabs,
   Text,
+  TextInput,
   ThemeIcon,
   Tooltip,
 } from "@mantine/core";
@@ -31,6 +33,7 @@ import {
   IconEye,
   IconFileCheck,
   IconFileText,
+  IconHexagonPlus,
   IconHome,
   IconReportSearch,
   IconShieldCheck,
@@ -39,8 +42,14 @@ import {
 import _ from "lodash";
 import React, { useCallback, useMemo, useState } from "react";
 import { Link } from "react-router-dom";
-import { formatCacheTtl, updateAssetObject } from "../../api/assets";
+import {
+  formatCacheTtl,
+  updateAssetObject,
+  mintAssetNft,
+} from "../../api/assets";
 import { Asset, AssetModel } from "../../api/types";
+import axios from "axios";
+import { buildApiUrl } from "../../api/utils";
 import {
   buildKeycloakAuthProvider,
   IIdentity,
@@ -127,6 +136,55 @@ export const AssetObjectShow: React.FC<IResourceComponentsProps> = () => {
   const { verificationCount } = useVerificationCount(assetObjectModel);
 
   const [isUpdatingName, setIsUpdatingName] = useState(false);
+  const [isMintModalOpen, setIsMintModalOpen] = useState(false);
+  const [mintLicense, setMintLicense] = useState("");
+  const [isMinting, setIsMinting] = useState(false);
+
+  const handleMintNft = useCallback(async () => {
+    if (!assetObjectModel || !mintLicense.trim()) return;
+
+    setIsMinting(true);
+
+    try {
+      const { task_id } = await mintAssetNft({
+        objectKeyOrId: assetObjectModel.data.id,
+        license: mintLicense.trim(),
+      });
+
+      // Poll the existing proof task endpoint until the task finishes
+      const poll = async (): Promise<void> => {
+        const url = buildApiUrl("asset", "proof", "task", String(task_id));
+        const res = await axios.get(url);
+        if (res.data?.finished_at) {
+          if (res.data?.error) {
+            throw new Error(res.data.error);
+          }
+          return;
+        }
+        await new Promise((r) => setTimeout(r, 3000));
+        return poll();
+      };
+
+      await poll();
+
+      open?.({
+        message: t("assetObjects.mintSuccess", "NFT minted successfully"),
+        type: "success",
+      });
+
+      setIsMintModalOpen(false);
+      setMintLicense("");
+      await queryResult.refetch();
+    } catch (error) {
+      _.partial(
+        catchErrorAndShow,
+        open,
+        t("assetObjects.mintError", "NFT minting failed"),
+      )(error);
+    } finally {
+      setIsMinting(false);
+    }
+  }, [assetObjectModel, mintLicense, open, t, queryResult]);
 
   const handleNameUpdate = useCallback(
     async (newName: string) => {
@@ -300,6 +358,43 @@ export const AssetObjectShow: React.FC<IResourceComponentsProps> = () => {
           "We are checking the integrity of this dataset object. This may take a while.",
         )}
       />
+      <LoadingOverlayWithMessage
+        visible={isMinting}
+        message={t(
+          "assetObjects.loadingMint",
+          "Minting NFT on the blockchain. This may take a minute.",
+        )}
+      />
+      <Modal
+        opened={isMintModalOpen}
+        onClose={() => {
+          if (!isMinting) {
+            setIsMintModalOpen(false);
+            setMintLicense("");
+          }
+        }}
+        title={t("assetObjects.mintNft.title", "Mint NFT")}
+      >
+        <TextInput
+          label={t("assetObjects.mintNft.license", "License")}
+          placeholder="e.g. CC-BY-4.0"
+          value={mintLicense}
+          onChange={(e) => setMintLicense(e.currentTarget.value)}
+          required
+          mb="md"
+        />
+        <Button
+          fullWidth
+          variant="light"
+          color="violet"
+          leftIcon={<IconHexagonPlus size={18} />}
+          loading={isMinting}
+          disabled={!mintLicense.trim()}
+          onClick={handleMintNft}
+        >
+          {t("assetObjects.mintNft.submit", "Mint NFT")}
+        </Button>
+      </Modal>
       {!!result && (
         <IntegrityModal
           integrityResult={result}
@@ -464,6 +559,24 @@ export const AssetObjectShow: React.FC<IResourceComponentsProps> = () => {
                     )}
                   </Button>
                 </Tooltip>
+
+                {assetObjectModel.data.proof_id && (
+                  <Tooltip
+                    label={t(
+                      "assetObjects.actions.mintNft",
+                      "Mint NFT for this object",
+                    )}
+                  >
+                    <Button
+                      variant="light"
+                      color="violet"
+                      leftIcon={<IconHexagonPlus size={18} />}
+                      onClick={() => setIsMintModalOpen(true)}
+                    >
+                      {t("assetObjects.actions.mintNft", "Mint NFT")}
+                    </Button>
+                  </Tooltip>
+                )}
               </Group>
             </Group>
           </Stack>
