Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403// keep-confirm.mjs - Confirm a client-side mint and update MongoDB// // POST /api/keep-confirm - Record a successful client-side wallet mint// This is called after the user signs the transaction with their wallet// to update the kidlisp record with mint information.
import crypto from "crypto";import { authorize } from "../../backend/authorization.mjs";import { connect } from "../../backend/database.mjs";import { respond } from "../../backend/http.mjs";import { loadKidlispPiece } from "../../backend/kidlisp-read.mjs";import { getKeepsContractAddress, LEGACY_KEEPS_CONTRACT } from "../../backend/tezos-keeps-contract.mjs";import { mirrorRecordMint } from "../../backend/kidlisp-dual-write.mjs";
const VERSION_BY_PROFILE = { v11: "11.0.0", v10: "10.0.0", v9: "9.0.0", v8: "8.0.0", v7: "7.0.0", v6: "6.0.0", v5: "5.0.0", v5rc: "5.0.0-rc", v4: "4.0.0",};
function normalizeTokenId(value) { if (value === null || typeof value === "undefined" || value === "") return null; const parsed = Number(value); if (!Number.isInteger(parsed) || parsed < 0) return null; return parsed;}
function normalizeNetwork(value) { const normalized = String(value || "mainnet").trim().toLowerCase(); return normalized === "ghostnet" ? "ghostnet" : "mainnet";}
function normalizeAddress(value) { return typeof value === "string" ? value.trim().toLowerCase() : "";}
function normalizeContractProfile(value) { if (typeof value !== "string") return null; const trimmed = value.trim().toLowerCase(); return trimmed || null;}
function normalizeContractVersion(value) { if (typeof value !== "string") return null; const trimmed = value.trim(); return trimmed || null;}
function pickString(value, network) { if (typeof value === "string" && value.trim()) return value.trim(); if (!value || typeof value !== "object" || Array.isArray(value)) return null; const candidate = value[network] || value.mainnet || value.current || value.default; return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;}
function resolveProfile(secretDoc, network) { const raw = pickString(secretDoc?.currentKeepsProfile, network) || pickString(secretDoc?.keepsProfile, network) || pickString(secretDoc?.keeps_profile, network) || pickString(secretDoc?.contractProfile, network) || pickString(secretDoc?.keeps?.profile, network); return normalizeContractProfile(raw) || "v11";}
function resolveVersion(secretDoc, profile, network) { const explicit = pickString(secretDoc?.currentKeepsVersion, network) || pickString(secretDoc?.keepsVersion, network) || pickString(secretDoc?.keeps_version, network) || pickString(secretDoc?.keeps?.version, network); return normalizeContractVersion(explicit) || VERSION_BY_PROFILE[profile] || null;}
async function resolveContractIdentity({ db, network, contractAddress, requestedProfile, requestedVersion,}) { let contractProfile = normalizeContractProfile(requestedProfile); let contractVersion = normalizeContractVersion(requestedVersion); const normalizedContract = normalizeAddress(contractAddress);
if (!contractProfile || !contractVersion) { try { const secretDoc = await db.collection("secrets").findOne({ _id: "tezos-kidlisp" }); const activeContract = await getKeepsContractAddress({ db, network, fallback: LEGACY_KEEPS_CONTRACT, }); const activeProfile = resolveProfile(secretDoc, network); const activeVersion = resolveVersion(secretDoc, activeProfile, network); const isActiveContract = normalizedContract && normalizeAddress(activeContract) === normalizedContract;
if (!contractProfile && (!normalizedContract || isActiveContract)) { contractProfile = activeProfile; } if (!contractVersion && (!normalizedContract || isActiveContract)) { contractVersion = activeVersion; } } catch (error) { console.warn("⚠️ keep-confirm: contract identity fallback failed:", error?.message || error); } }
if (!contractProfile && normalizedContract === normalizeAddress(LEGACY_KEEPS_CONTRACT)) { contractProfile = "legacy"; } if (!contractVersion && contractProfile) { contractVersion = VERSION_BY_PROFILE[contractProfile] || null; }
return { contractProfile, contractVersion };}
function tzktApiBase(network) { return network === "mainnet" ? "https://api.tzkt.io" : `https://api.${network}.tzkt.io`;}
function stringToHex(value) { return Buffer.from(String(value || ""), "utf8").toString("hex");}
function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms));}
async function fetchOperationState({ txHash, network }) { const base = tzktApiBase(network); const url = `${base}/v1/operations/transactions/${txHash}`;
try { const response = await fetch(url); if (!response.ok) return { known: false, applied: false, failed: false }; const txs = await response.json(); if (!Array.isArray(txs) || txs.length === 0) return { known: false, applied: false, failed: false }; const statuses = txs.map((tx) => tx?.status).filter(Boolean); const failed = statuses.some((s) => s === "failed" || s === "backtracked"); const applied = statuses.some((s) => s === "applied"); return { known: true, applied, failed }; } catch (error) { return { known: false, applied: false, failed: false }; }}
async function resolveTokenIdFromChain({ piece, contractAddress, network, retries = 20, delayMs = 1500 }) { const keyBytes = stringToHex(piece); const base = tzktApiBase(network); const url = `${base}/v1/contracts/${contractAddress}/bigmaps/content_hashes/keys/${keyBytes}`;
for (let i = 0; i < retries; i++) { try { const response = await fetch(url); if (response.ok) { const data = await response.json(); const tokenId = normalizeTokenId(data?.value); if (data?.active && tokenId !== null) { return tokenId; } } } catch (_) { // Retry on transient API/indexing errors } if (i < retries - 1) { await delay(delayMs); } }
return null;}
export async function handler(event, context) { if (event.httpMethod === "OPTIONS") { return respond(204, ""); }
if (event.httpMethod !== "POST") { return respond(405, { error: "Method not allowed" }); }
let database; try { database = await connect(); } catch (connectError) { console.error("❌ MongoDB connection failed:", connectError.message); return respond(503, { error: "Database temporarily unavailable" }); }
try { // Verify user is authenticated const user = await authorize(event.headers); if (!user) { await database.disconnect(); return respond(401, { error: "Authentication required" }); }
// Parse body const body = JSON.parse(event.body || "{}"); const { piece, tokenId, txHash, walletAddress, network, contractAddress, contractProfile, contractVersion, artifactUri, thumbnailUri, metadataUri, } = body;
if (!piece || !txHash) { await database.disconnect(); return respond(400, { error: "Missing piece or txHash" }); }
// Clean piece name (remove $ prefix if present) const cleanPiece = piece.replace(/^\$/, ""); const normalizedNetwork = normalizeNetwork(network); const effectiveContractAddress = typeof contractAddress === "string" && contractAddress.trim() ? contractAddress.trim() : null; const normalizedTxHash = String(txHash || "").trim(); const tokenIdFromRequest = normalizeTokenId(tokenId); const contractIdentity = await resolveContractIdentity({ db: database.db, network: normalizedNetwork, contractAddress: effectiveContractAddress, requestedProfile: contractProfile, requestedVersion: contractVersion, });
// Find the kidlisp record (Datomic-aware; new pieces live only in Datomic) const collection = database.db.collection("kidlisp"); const record = await loadKidlispPiece(database, cleanPiece);
if (!record) { await database.disconnect(); return respond(404, { error: `Piece '$${cleanPiece}' not found` }); }
// Verify ownership (user must own the piece or be admin) if (record.user && record.user !== user.sub) { console.warn(`❌ User ${user.sub} tried to confirm mint for piece owned by ${record.user}`); await database.disconnect(); return respond(403, { error: "Not authorized to confirm this mint" }); }
// Check operation status when indexer already sees it const operationState = await fetchOperationState({ txHash: normalizedTxHash, network: normalizedNetwork, }); if (operationState.failed) { await database.disconnect(); return respond(400, { error: "Mint transaction failed on-chain", txHash: normalizedTxHash }); }
// Resolve token id from request first, then from on-chain content_hashes bigmap. let resolvedTokenId = tokenIdFromRequest; if (resolvedTokenId === null && effectiveContractAddress) { resolvedTokenId = await resolveTokenIdFromChain({ piece: cleanPiece, contractAddress: effectiveContractAddress, network: normalizedNetwork, }); }
const now = new Date(); const setOps = {}; const unsetOps = {};
if (effectiveContractAddress) { const basePath = `tezos.contracts.${effectiveContractAddress}`; setOps[`${basePath}.txHash`] = normalizedTxHash; setOps[`${basePath}.network`] = normalizedNetwork; setOps[`${basePath}.owner`] = walletAddress || null; setOps[`${basePath}.walletAddress`] = walletAddress || null; setOps[`${basePath}.artifactUri`] = artifactUri || null; setOps[`${basePath}.thumbnailUri`] = thumbnailUri || null; setOps[`${basePath}.metadataUri`] = metadataUri || null; setOps[`${basePath}.lastConfirmAt`] = now; setOps[`${basePath}.minted`] = resolvedTokenId !== null; setOps[`${basePath}.pending`] = resolvedTokenId === null; setOps[`${basePath}.contractProfile`] = contractIdentity.contractProfile || null; setOps[`${basePath}.contractVersion`] = contractIdentity.contractVersion || null; if (resolvedTokenId !== null) { setOps[`${basePath}.tokenId`] = resolvedTokenId; setOps[`${basePath}.mintedAt`] = now; } }
if (resolvedTokenId !== null) { setOps.kept = { tokenId: resolvedTokenId, txHash: normalizedTxHash, walletAddress: walletAddress || null, network: normalizedNetwork, contractAddress: effectiveContractAddress, contractProfile: contractIdentity.contractProfile || null, contractVersion: contractIdentity.contractVersion || null, artifactUri: artifactUri || null, thumbnailUri: thumbnailUri || null, metadataUri: metadataUri || null, keptAt: now, keptBy: user.sub, }; } else { setOps.pendingKeep = { txHash: normalizedTxHash, walletAddress: walletAddress || null, network: normalizedNetwork, contractAddress: effectiveContractAddress, contractProfile: contractIdentity.contractProfile || null, contractVersion: contractIdentity.contractVersion || null, artifactUri: artifactUri || null, thumbnailUri: thumbnailUri || null, metadataUri: metadataUri || null, requestedAt: now, requestedBy: user.sub, }; const existingTokenId = normalizeTokenId(record?.kept?.tokenId); if (record?.kept && existingTokenId === null) { unsetOps.kept = ""; } }
if (resolvedTokenId !== null) { unsetOps.pendingKeep = ""; }
// upsert: pieces that live only in Datomic (KIDLISP_DATOMIC=on) don't // yet have a Mongo row on first keep. Writing on upsert creates one so // ipfsMedia / kept persist. Seed the row's identity fields on insert from // the Datomic record so it never lands as a hash-less { hash: null } doc. const setOnInsert = {}; if (typeof record?.source === "string" && record.source.length > 0) { setOnInsert.source = record.source; setOnInsert.hash = crypto .createHash("sha256") .update(record.source.trim()) .digest("hex"); setOnInsert.when = now; }
const updateResult = await collection.updateOne( { code: cleanPiece }, { $set: setOps, ...(Object.keys(unsetOps).length > 0 ? { $unset: unsetOps } : {}), ...(Object.keys(setOnInsert).length > 0 ? { $setOnInsert: setOnInsert } : {}), }, { upsert: true } );
if (updateResult.modifiedCount === 0 && updateResult.matchedCount === 0 && !updateResult.upsertedId) { console.warn(`❌ Failed to update piece ${cleanPiece}`); await database.disconnect(); return respond(500, { error: "Failed to record mint" }); }
if (resolvedTokenId !== null) { await mirrorRecordMint(cleanPiece, setOps.kept, { source: "kept" }); }
console.log(`✅ Recorded keep for $${cleanPiece} - Token #${resolvedTokenId ?? "pending"} on ${normalizedNetwork}`); console.log(` TX: ${normalizedTxHash}`); console.log(` Wallet: ${walletAddress || "unknown"}`);
await database.disconnect();
return respond(200, { success: true, piece: cleanPiece, tokenId: resolvedTokenId, network: normalizedNetwork, contractProfile: contractIdentity.contractProfile || null, contractVersion: contractIdentity.contractVersion || null, pending: resolvedTokenId === null, message: resolvedTokenId === null ? `Mint submitted on ${normalizedNetwork.toUpperCase()} (awaiting index confirmation)` : `Recorded as kept on ${normalizedNetwork.toUpperCase()}`, });
} catch (error) { console.error("❌ Keep confirm error:", error); if (database) await database.disconnect(); return respond(500, { error: error.message || "Failed to confirm mint" }); }}