ADR-019: NFT Minting Infrastructure Integration

Date: 2025-11-09 Status: 🤔 Proposed Decision Makers: Architecture Team Related ADRs: ADR-008 (EmProps UI Monorepo Integration)

Executive Summary

This ADR proposes integrating the EmProps NFT minting infrastructure (three standalone packages: emprops-hardhat, emprops-ponder, emprops-react-web3) from the nft_investigation workspace into the emerge-turbo monorepo. The integration enables users to launch NFT collections from AI-generated content, creating a proof-of-concept for blockchain-based content monetization.

Current State:

✅ Smart Contracts - Complete Solidity implementation in /Users/the_dusky/code/emprops/nft_investigation/emprops-hardhat
✅ Blockchain Indexer - Ponder-based event indexing in /Users/the_dusky/code/emprops/nft_investigation/emprops-ponder
✅ React Web3 SDK - Demo implementation in /Users/the_dusky/code/emprops/nft_investigation/emprops-react-web3
❌ Integration - No connection to emerge-turbo platform

Target State:

✅ Complete NFT Stack - Smart contracts, indexer, and launchpad UI integrated into monorepo
✅ User Flow - "Launch as NFT" button in emprops-studio → NFT launchpad → payment → content generation → NFT minting
✅ Proof of Concept - Self-contained NFT modules with minimal changes to existing apps

Key Decision: How do we integrate three separate NFT packages into emerge-turbo while maintaining isolation and creating a working proof-of-concept?

Context
Problem Statement
Decision
Technical Architecture
Implementation Strategy
Monorepo Structure
Integration Points
Migration Challenges
Consequences
Alternatives Considered
Related Documentation

Context

Current NFT Infrastructure

The EmProps NFT system was developed 8 months ago as a proof-of-concept for blockchain-based ownership of AI-generated content. It consists of three packages:

nft_investigation/
├── emprops-hardhat/        # Smart contract development & deployment
│   ├── contracts/           # Solidity contracts (in backup/)
│   ├── deploy/              # Hardhat deployment scripts
│   ├── scripts/             # DB integration & simulation
│   └── backup/hardhat/      # ✅ COMPLETE CONTRACT IMPLEMENTATIONS
│       └── contracts/
│           ├── OwnerTokenContract.sol          # Master NFT for collection ownership
│           ├── AppFactoryContract.sol          # CREATE2 factory for NFT collections
│           ├── SimpleAppContract.sol           # ERC721A NFT collection
│           └── SimpleAppInitializerContract.sol # Collection configuration
│
├── emprops-ponder/         # Blockchain event indexing & API
│   ├── src/api/             # Hono HTTP API + WebSocket server
│   ├── src/handlers/        # Event handlers for contract monitoring
│   ├── ponder.schema.ts     # 8-table PostgreSQL schema
│   └── ponder.config.ts     # Dynamic contract configuration
│
└── emprops-react-web3/     # React hooks & components (DEMO)
    ├── src/hooks/           # useGetSimpleApps, useMintToken, etc.
    ├── src/adapter/         # WagmiAdapter + PonderAdapter
    ├── src/provider/        # EmPropsProvider context
    └── src/test/manual/     # Manual testing components

Existing emerge-turbo Architecture

The monorepo already has relevant infrastructure:

emerge-turbo/
├── apps/
│   ├── emprops-studio/      # Next.js UI (target for "Launch NFT" button)
│   ├── emprops-api/         # Express API (could handle NFT operations)
│   ├── monitor/             # Real-time dashboard (could show NFT metrics)
│   └── api/                 # Core job orchestration
│
└── packages/
    ├── @emp/core/           # Shared utilities, Redis, OTEL
    ├── @emp/database/       # Prisma client
    └── component-library/   # Shared React components

Business Context

Goal: Enable users to monetize AI-generated content through NFT collections

User Journey:

User creates AI content in emprops-studio (existing flow)
User clicks "Launch as NFT Collection" button (NEW)
NFT launchpad opens with collection configuration form (NEW)
User configures: name, symbol, max supply, mint price, etc.
Payment validation (future: could require payment or NFT ownership)
Content generation using existing ComfyUI workflows
NFT collection deployed on-chain
NFTs minted with AI-generated content as metadata

Constraints:

✅ Proof of concept - self-contained, minimal impact on existing code
✅ New button in emprops-studio is the ONLY change to existing apps
✅ All NFT functionality isolated in new modules
✅ Can be tested independently

Problem Statement

Challenges

Three Separate Repositories
- How do we consolidate without losing functionality?
- How do we maintain the contract deployment pipeline?
- How do we integrate blockchain indexing (Ponder) with existing infrastructure?
React Web3 SDK is a Demo
- The current emprops-react-web3 is a demo/testing harness
- Need to extract useful patterns and integrate into actual UI
- Don't want to duplicate Web3 libraries (Wagmi, RainbowKit)
Database Management
- emprops-hardhat uses PostgreSQL for deployment tracking
- emprops-ponder uses PostgreSQL for event indexing
- emerge-turbo already has Prisma + PostgreSQL
- How do we consolidate database usage?
Minimal Integration
- Only a single button should change in emprops-studio
- All NFT features must be self-contained
- Need clear boundaries between existing platform and NFT modules
Smart Contract State
- Contracts are in backup/ folder, not main contracts folder
- Need to validate they compile and work
- Deployment scripts reference database storage

Decision

Integration Approach: Modular Proof-of-Concept Architecture

We will integrate the NFT infrastructure as three new modules in the monorepo with minimal coupling to existing services:

packages/nft-contracts - Smart contract package (from emprops-hardhat)
apps/nft-indexer - Ponder-based blockchain indexer (from emprops-ponder)
apps/nft-launchpad - Next.js NFT collection launchpad UI (NEW, inspired by emprops-react-web3)

Key Principles

✅ Isolation First - NFT modules are self-contained with clear APIs ✅ Minimal Touch Points - Single button in emprops-studio, everything else is new ✅ Proof of Concept - Not production-critical, can iterate independently ✅ Reuse Patterns - Learn from emprops-react-web3 but don't copy it wholesale ✅ Database Coexistence - NFT indexer uses separate schema, not Prisma

Technical Architecture

High-Level Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     emerge-turbo Monorepo                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────┐         ┌──────────────────┐              │
│  │ emprops-studio  │────────▶│ nft-launchpad    │              │
│  │                 │ "Launch │ (Next.js)        │              │
│  │ (existing app)  │  NFT"   │ - Collection UI  │              │
│  │                 │ button  │ - Minting UI     │              │
│  └─────────────────┘         │ - Payment flow   │              │
│                               └──────────────────┘              │
│                                        │                         │
│                                        │ Web3 calls              │
│                                        ▼                         │
│                               ┌──────────────────┐              │
│                               │ Blockchain       │              │
│                               │ (Base/Ethereum)  │              │
│                               │                  │              │
│                               │ - OwnerToken     │              │
│                               │ - AppFactory     │              │
│                               │ - SimpleApp      │              │
│                               └──────────────────┘              │
│                                        │                         │
│                                        │ Events                  │
│                                        ▼                         │
│                               ┌──────────────────┐              │
│                               │ nft-indexer      │              │
│                               │ (Ponder)         │              │
│                               │ - Event handlers │              │
│                               │ - PostgreSQL     │              │
│                               │ - WebSocket API  │              │
│                               └──────────────────┘              │
│                                        │                         │
│                                        │ Real-time data          │
│                                        ▼                         │
│                               ┌──────────────────┐              │
│                               │ monitor          │              │
│                               │ (existing)       │              │
│                               │ + NFT metrics    │              │
│                               └──────────────────┘              │
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │ packages/nft-contracts                                    │  │
│  │ - Solidity contracts                                      │  │
│  │ - Hardhat config                                          │  │
│  │ - Deployment scripts                                      │  │
│  │ - TypeChain generated types                               │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Smart Contract Architecture

Contract Hierarchy:

OwnerTokenContract (ERC721A Upgradeable)
    │
    └─── Represents ownership of an NFT collection
         Each token ID = ownership of one collection

AppFactoryContract (UUPS Upgradeable)
    │
    ├─── Creates new NFT collections using CREATE2
    ├─── Deterministic addresses (same on all chains)
    └─── Mints OwnerToken when collection is created

SimpleAppContract (ERC721A, Minimal Proxy)
    │
    ├─── Individual NFT collection
    ├─── Controlled by OwnerToken holder
    ├─── Configurable: maxSupply, mintPrice, maxPerMint, startTime
    └─── Public minting with payment

Key Features:

ERC721A - Gas-optimized batch minting
UUPS Upgradeable - Can upgrade factory and owner token
ERC1167 Minimal Proxy - Cheap collection deployment (~$5 vs ~$200)
Cross-chain Compatible - Same collection address on all chains (CREATE2)
Owner Token Gating - Only OwnerToken holder can manage collection

Monorepo Structure

Proposed Directory Layout

emerge-turbo/
├── apps/
│   ├── emprops-studio/          # EXISTING (minimal change)
│   │   └── pages/
│   │       └── studio/apps/v2/
│   │           └── [id].tsx     # ✏️ ADD: "Launch as NFT" button
│   │
│   ├── nft-launchpad/           # 🆕 NEW APP
│   │   ├── pages/
│   │   │   ├── _app.tsx         # Wagmi + RainbowKit providers
│   │   │   ├── index.tsx        # Collection gallery
│   │   │   ├── create.tsx       # Create collection form
│   │   │   └── [collection]/
│   │   │       ├── index.tsx    # Collection details
│   │   │       └── mint.tsx     # Minting interface
│   │   ├── components/
│   │   │   ├── CollectionCard.tsx
│   │   │   ├── MintButton.tsx
│   │   │   └── CreateCollectionForm.tsx
│   │   ├── hooks/
│   │   │   ├── useCreateCollection.ts
│   │   │   ├── useMintNFT.ts
│   │   │   └── useCollections.ts
│   │   ├── lib/
│   │   │   ├── wagmi.ts         # Wagmi configuration
│   │   │   └── contracts.ts     # Contract addresses & ABIs
│   │   └── package.json
│   │
│   ├── nft-indexer/             # 🆕 NEW APP (from emprops-ponder)
│   │   ├── src/
│   │   │   ├── api/
│   │   │   │   ├── index.ts     # Hono API routes
│   │   │   │   └── sockets/     # WebSocket server
│   │   │   ├── handlers/
│   │   │   │   ├── OwnerToken.ts
│   │   │   │   ├── AppFactory.ts
│   │   │   │   └── SimpleApp.ts
│   │   │   └── utils/
│   │   │       └── db.ts        # Contract registry
│   │   ├── ponder.config.ts     # Dynamic contract loading
│   │   ├── ponder.schema.ts     # 8-table schema
│   │   └── package.json
│   │
│   ├── monitor/                 # EXISTING (optional enhancement)
│   │   └── pages/
│   │       └── nft-metrics.tsx  # 🔧 OPTIONAL: NFT dashboard
│   │
│   └── emprops-api/             # EXISTING (optional enhancement)
│       └── src/routes/
│           └── nft.ts           # 🔧 OPTIONAL: NFT metadata API
│
├── packages/
│   ├── nft-contracts/           # 🆕 NEW PACKAGE (from emprops-hardhat)
│   │   ├── contracts/
│   │   │   ├── OwnerTokenContract.sol
│   │   │   ├── AppFactoryContract.sol
│   │   │   ├── SimpleAppContract.sol
│   │   │   ├── SimpleAppInitializerContract.sol
│   │   │   ├── interfaces/
│   │   │   └── proxy/
│   │   ├── deploy/
│   │   │   ├── 00_owner_token.ts
│   │   │   ├── 01_app_factory.ts
│   │   │   └── 02_simple_app_impl.ts
│   │   ├── scripts/
│   │   │   ├── db/              # Database storage scripts
│   │   │   └── simulate/        # Contract testing scripts
│   │   ├── test/
│   │   ├── hardhat.config.ts
│   │   ├── tsconfig.json
│   │   └── package.json
│   │
│   └── @emp/core/              # EXISTING (no changes)
│
└── pnpm-workspace.yaml         # EXISTING (already includes packages/*, apps/*)

Package Naming Conventions

nft-contracts - Contains smart contracts (not @emp/nft-contracts to keep Hardhat independent)
nft-indexer - Ponder application (app, not package)
nft-launchpad - Next.js frontend application

Implementation Strategy

Phase 1: Documentation & Validation (Week 1)

Goal: Understand what we have and validate it works

Create comprehensive documentation for each of the three repos:
- Document contract architecture and deployment flow
- Document Ponder indexing setup and API
- Document React Web3 patterns worth keeping

Validate contracts compile and test:

bash

cd emprops-hardhat
pnpm install
pnpm compile
pnpm test

Review and create final integration plan

Phase 2: Contract Package Migration (Week 1-2)

Goal: Get smart contracts into monorepo and deployable

Create packages/nft-contracts:
- Copy contracts from backup/hardhat/contracts/ to packages/nft-contracts/contracts/
- Copy deployment scripts
- Update hardhat.config.ts for monorepo context
- Update database storage scripts to use shared PostgreSQL

Test compilation:

bash

pnpm --filter nft-contracts compile
pnpm --filter nft-contracts test

Deploy to testnet (Base Sepolia):

bash

pnpm --filter nft-contracts deploy --network baseSepolia

Store deployment info in database for Ponder to read

Phase 3: Indexer App Migration (Week 2)

Goal: Get Ponder indexer running and tracking events

Create apps/nft-indexer:
- Copy from emprops-ponder
- Update ponder.config.ts to read contracts from monorepo database
- Ensure PostgreSQL schema doesn't conflict with Prisma
Test locally:
bash
```
pnpm --filter nft-indexer dev
```
1
Verify API endpoints:
- GET /api/apps - List all NFT collections
- GET /api/owner-tokens - List owner tokens
- WebSocket connection for real-time events

Phase 4: Launchpad App Creation (Week 2-3)

Goal: Create NFT launchpad UI inspired by emprops-react-web3

Create apps/nft-launchpad (new Next.js app):
- Set up Wagmi + RainbowKit configuration
- Create collection creation form
- Create minting interface
- Connect to nft-indexer API for data
Extract useful patterns from emprops-react-web3:
- Adapter pattern (WagmiAdapter for on-chain, API for indexed data)
- React Query integration
- Transaction hooks pattern
- Error handling patterns
DO NOT copy wholesale:
- Don't create another provider package
- Build hooks directly in nft-launchpad
- Use established patterns from emprops-studio

Phase 5: emprops-studio Integration (Week 3)

Goal: Add "Launch as NFT" button - THE ONLY CHANGE to existing apps

Add button to app pages:

tsx

// apps/emprops-studio/pages/studio/apps/v2/[id].tsx
<Button onClick={() => router.push('/nft-launchpad/create?sourceApp=' + id)}>
  Launch as NFT Collection
</Button>

Pass context to launchpad:
- App ID
- Generated content reference
- User wallet (if connected)
That's it - all other NFT functionality is in nft-launchpad

Phase 6: Testing & Documentation (Week 3-4)

Goal: Validate end-to-end flow and document

Test complete flow:
- Click "Launch as NFT" in emprops-studio
- Configure collection in nft-launchpad
- Deploy collection on testnet
- Verify indexer picks up events
- Mint NFTs
- Verify ownership
Create documentation:
- User guide for NFT launching
- Developer guide for contracts
- API documentation for indexer
Optional: Add metrics to monitor:
- Collections created
- NFTs minted
- Total revenue

Integration Points

1. emprops-studio → nft-launchpad

Touch Point: Single button in app pages

tsx

// apps/emprops-studio/pages/studio/apps/v2/[id].tsx
import Link from 'next/link';

// Inside component render:
<Link href={`/nft-launchpad/create?sourceApp=${appId}`}>
  <Button>Launch as NFT Collection</Button>
</Link>

Data Flow:

App ID passed via query parameter
nft-launchpad reads app details (could call emprops-api)
User configures NFT collection
Collection deployed independently

2. nft-launchpad → nft-indexer

Touch Point: REST API + WebSocket for data

typescript

// apps/nft-launchpad/lib/api.ts
const NFT_INDEXER_URL = process.env.NEXT_PUBLIC_NFT_INDEXER_URL;

export async function getCollections() {
  const response = await fetch(`${NFT_INDEXER_URL}/api/apps`);
  return response.json();
}

// WebSocket for real-time updates
const socket = io(NFT_INDEXER_URL);
socket.on('emprops:appToken:minted', (data) => {
  // Update UI
});

3. nft-indexer → Blockchain

Touch Point: Ponder reads contract events

typescript

// apps/nft-indexer/ponder.config.ts
export default {
  networks: {
    baseSepolia: {
      chainId: 84532,
      transport: http(process.env.PONDER_RPC_URL_84532)
    }
  },
  contracts: {
    AppFactory: {
      // Dynamically loaded from database
      abi: AppFactoryAbi,
      address: await getContractAddress('AppFactoryProxyContract'),
      network: 'baseSepolia',
      startBlock: deploymentBlock
    }
  }
}

4. nft-contracts → Database

Touch Point: Deployment info stored for indexer

typescript

// packages/nft-contracts/scripts/db/storeDeployments.ts
await pool.query(`
  INSERT INTO contract_deployments (name, address, network, abi)
  VALUES ($1, $2, $3, $4)
`, [contractName, address, networkName, JSON.stringify(abi)]);

5. Optional: monitor → nft-indexer

Touch Point: Display NFT metrics (future enhancement)

tsx

// apps/monitor/pages/nft-metrics.tsx
import useSWR from 'swr';

export default function NFTMetrics() {
  const { data } = useSWR('/api/nft-stats', fetcher);

  return (
    <div>
      <Metric label="Collections Created" value={data?.collections} />
      <Metric label="NFTs Minted" value={data?.minted} />
    </div>
  );
}

Migration Challenges

1. Database Coexistence

Challenge: emprops-hardhat and emprops-ponder both use PostgreSQL, but emerge-turbo uses Prisma

Solution:

NFT packages use separate schemas in same PostgreSQL instance
Don't integrate with Prisma (keep isolated)
Create nft_contracts and nft_indexer schemas
Ponder manages its own schema (already does this)

sql

-- Database structure
postgres://
├── public                  # emerge-turbo Prisma schema
├── nft_contracts          # Contract deployments (Hardhat)
└── ponder_*               # Ponder indexer tables (auto-managed)

2. Contract Location

Challenge: Contracts currently in backup/ folder

Solution:

Move from backup/hardhat/contracts/ to packages/nft-contracts/contracts/
Validate compilation
Update deployment scripts
Run tests to ensure nothing broke

3. React Web3 SDK is a Demo

Challenge: emprops-react-web3 is a testing harness, not production code

Solution:

Don't migrate emprops-react-web3 as a package
Extract useful patterns:
- Adapter pattern for dual data sources
- Transaction hooks structure
- React Query integration
Build fresh in nft-launchpad using these patterns
Reference emprops-react-web3 as documentation only

4. Dependency Duplication

Challenge: NFT packages have many overlapping dependencies with emerge-turbo

Solution:

Use workspace protocol: "@emp/core": "workspace:*"
Share where possible: TypeScript, Prettier, ESLint configs
Keep separate where needed: Wagmi, Viem versions for Web3 compatibility

5. Port Conflicts

Challenge: Multiple apps need to run simultaneously

Solution:

emprops-studio:  3336 (existing)
nft-launchpad:   3337 (new)
nft-indexer:     3338 (new)
monitor:         3334 (existing)

6. Environment Variables

Challenge: Each package needs different config

Solution:

Create .env.nft for NFT-specific variables
Use dotenv-cli to load: dotenv -e .env.nft -- pnpm dev
Document required variables:

bash

# .env.nft
NFT_INDEXER_URL=http://localhost:3338
NEXT_PUBLIC_NFT_INDEXER_URL=http://localhost:3338
PONDER_RPC_URL_84532=https://base-sepolia.g.alchemy.com/v2/YOUR_KEY
PONDER_DATABASE_URL=postgresql://localhost/nft_investigation
HARDHAT_DATABASE_URL=postgresql://localhost/nft_investigation
DEPLOYER_PRIVATE_KEY=0x...

Consequences

Positive Consequences

✅ Unified Codebase

Single repo for entire platform (AI + NFT)
Easier to coordinate releases
Shared tooling and CI/CD

✅ Proof of Concept Isolation

NFT features are self-contained
Can iterate independently
Minimal risk to existing platform

✅ Clear Boundaries

One button in emprops-studio
All NFT complexity isolated in new modules
Easy to remove if POC fails

✅ Reusable Infrastructure

Indexer pattern can be reused for other on-chain features
Contract deployment pipeline established
Web3 integration patterns documented

✅ Learning Foundation

Team learns blockchain integration
Establishes patterns for future Web3 features
Creates monetization pathway

Negative Consequences

⚠️ Increased Complexity

More apps to manage (3 new)
Blockchain dependencies add uncertainty
Need to understand Solidity, Hardhat, Ponder

⚠️ External Dependencies

Blockchain RPC reliability
Gas costs for deployment
Smart contract security risks

⚠️ Database Proliferation

Multiple schemas in PostgreSQL
Not using Prisma for NFT data
More database management overhead

⚠️ Separate Deployment

Smart contracts deployed independently
Indexer needs to be running
Launchpad depends on both

Mitigation Strategies

Gradual Rollout
- Start with testnet only
- Internal testing first
- Limited beta with select users
Documentation
- Comprehensive setup guides
- Architecture diagrams
- Troubleshooting playbook
Monitoring
- Contract event tracking
- Indexer health checks
- Transaction failure alerts
Fallback Plan
- Can remove NFT modules without impacting platform
- Contracts are immutable once deployed
- Keep emprops-react-web3 as reference

Alternatives Considered

Alternative 1: Keep NFT Infrastructure Separate

Approach: Leave emprops-hardhat, emprops-ponder, emprops-react-web3 as separate repos

Pros:

No migration effort
Clear separation of concerns
Independent versioning

Cons:

Harder to integrate with emprops-studio
Duplicate tooling and setup
Split deployment pipeline
Rejected: Goal is integration, not separation

Alternative 2: Full Integration with Shared Infrastructure

Approach: Integrate NFT data into Prisma, use emprops-api for all NFT operations

Pros:

Single API
Unified database
Consistent patterns

Cons:

High coupling
Blockchain data doesn't fit Prisma model well
Changes Ponder's auto-managed schema approach
Rejected: Too much coupling for a proof of concept

Alternative 3: Microservices with Separate Deployment

Approach: Deploy NFT services independently, integrate via API only

Pros:

True isolation
Independent scaling
Can use different tech stack

Cons:

Deployment complexity
Cross-service coordination
Network latency
Rejected: Overkill for proof of concept

Alternative 4: Serverless Functions for NFT Operations

Approach: Use Vercel/Netlify functions instead of dedicated apps

Pros:

Auto-scaling
Pay-per-use
Simpler deployment

Cons:

Ponder can't run serverless (needs persistent process)
Smart contract deployment needs local setup
Cold start issues for blockchain calls
Rejected: Ponder requires long-running process

ADRs

ADR-008: EmProps UI Monorepo Integration (similar migration pattern)
ADR-006: Logging Architecture (shared observability approach)

Technical Docs

EmProps NFT Architecture (to be created)
Smart Contract Deployment Guide (to be created)
Ponder Indexer Setup (to be created)

External References

Decision Log

Date	Decision	Rationale
2025-11-09	Integrate as three separate modules	Maintains isolation for POC
2025-11-09	Don't migrate emprops-react-web3 as package	It's a demo, extract patterns instead
2025-11-09	Use separate database schemas	Avoid Prisma/Ponder conflicts
2025-11-09	Single button in emprops-studio only	Minimal touch point reduces risk

Next Steps

Create comprehensive documentation of three repos (emprops-hardhat, emprops-ponder, emprops-react-web3)
Validate contracts compile and test in current location
Review and approve this ADR
Create detailed implementation plan with week-by-week tasks
Begin Phase 1: Documentation & Validation

Appendix: Contract Details

OwnerTokenContract

Purpose: Master NFT representing ownership of an NFT collection

Key Functions:

factoryMint(address to) - Mint new owner token (factory only)
getTokensByOwner(address owner) - Get all tokens for an address
setFactory(address factory) - Set authorized factory (one-time)

Upgrade Pattern: UUPS (owner can upgrade)

AppFactoryContract

Purpose: Factory for creating NFT collections with deterministic addresses

Key Functions:

registerImplementation(address impl, address initializer) - Register new app type
createApp(bytes32 appType, string appId, ...) - Create new collection
predictAppAddress(bytes32 appType, bytes32 salt) - Preview deployment address

Upgrade Pattern: UUPS (owner can upgrade)

SimpleAppContract

Purpose: Individual ERC721A NFT collection

Key Functions:

mint(uint256 quantity) - Public minting with payment
withdraw() - Owner withdraws sales proceeds
setPaused(bool paused) - Owner pauses/unpauses minting
setMaxSupply(uint256), setMintPrice(uint256), etc. - Owner/initializer config

Upgrade Pattern: Minimal Proxy (cheap deployment, not upgradeable)

SimpleAppInitializerContract

Purpose: One-time initialization of SimpleApp parameters

Key Functions:

initializeApp(address app, bytes initData) - Set minting parameters

Pattern: Immutable (deployed per factory)

Status: 🤔 Awaiting approval

Approvers:

[ ] Technical Lead
[ ] Product Owner
[ ] DevOps Lead

Approval Date: Pending

ADR-019: NFT Minting Infrastructure Integration ​

Executive Summary ​

Table of Contents ​

Context ​

Current NFT Infrastructure ​

Existing emerge-turbo Architecture ​

Business Context ​

Problem Statement ​

Challenges ​

Decision ​

Integration Approach: Modular Proof-of-Concept Architecture ​

Key Principles ​

Technical Architecture ​

High-Level Architecture ​

Smart Contract Architecture ​

Monorepo Structure ​

Proposed Directory Layout ​

Package Naming Conventions ​

Implementation Strategy ​

Phase 1: Documentation & Validation (Week 1) ​

Phase 2: Contract Package Migration (Week 1-2) ​

Phase 3: Indexer App Migration (Week 2) ​

Phase 4: Launchpad App Creation (Week 2-3) ​

Phase 5: emprops-studio Integration (Week 3) ​

Phase 6: Testing & Documentation (Week 3-4) ​

Integration Points ​

1. emprops-studio → nft-launchpad ​

2. nft-launchpad → nft-indexer ​

3. nft-indexer → Blockchain ​

4. nft-contracts → Database ​

5. Optional: monitor → nft-indexer ​

Migration Challenges ​

1. Database Coexistence ​

2. Contract Location ​

3. React Web3 SDK is a Demo ​

4. Dependency Duplication ​

5. Port Conflicts ​

6. Environment Variables ​

Consequences ​

Positive Consequences ​

Negative Consequences ​

Mitigation Strategies ​

Alternatives Considered ​

Alternative 1: Keep NFT Infrastructure Separate ​

Alternative 2: Full Integration with Shared Infrastructure ​

Alternative 3: Microservices with Separate Deployment ​

Alternative 4: Serverless Functions for NFT Operations ​

Related Documentation ​

ADRs ​

Technical Docs ​

External References ​

Decision Log ​

Next Steps ​

Appendix: Contract Details ​

OwnerTokenContract ​

AppFactoryContract ​

SimpleAppContract ​

SimpleAppInitializerContract ​

ADR-019: NFT Minting Infrastructure Integration

Executive Summary

Table of Contents

Context

Current NFT Infrastructure

Existing emerge-turbo Architecture

Business Context

Problem Statement

Challenges

Decision

Integration Approach: Modular Proof-of-Concept Architecture

Key Principles

Technical Architecture

High-Level Architecture

Smart Contract Architecture

Monorepo Structure

Proposed Directory Layout

Package Naming Conventions

Implementation Strategy

Phase 1: Documentation & Validation (Week 1)

Phase 2: Contract Package Migration (Week 1-2)

Phase 3: Indexer App Migration (Week 2)

Phase 4: Launchpad App Creation (Week 2-3)

Phase 5: emprops-studio Integration (Week 3)

Phase 6: Testing & Documentation (Week 3-4)

Integration Points

1. emprops-studio → nft-launchpad

2. nft-launchpad → nft-indexer

3. nft-indexer → Blockchain

4. nft-contracts → Database

5. Optional: monitor → nft-indexer

Migration Challenges

1. Database Coexistence

2. Contract Location

3. React Web3 SDK is a Demo

4. Dependency Duplication

5. Port Conflicts

6. Environment Variables

Consequences

Positive Consequences

Negative Consequences

Mitigation Strategies

Alternatives Considered

Alternative 1: Keep NFT Infrastructure Separate

Alternative 2: Full Integration with Shared Infrastructure

Alternative 3: Microservices with Separate Deployment

Alternative 4: Serverless Functions for NFT Operations

Related Documentation

ADRs

Technical Docs

External References

Decision Log

Next Steps

Appendix: Contract Details

OwnerTokenContract

AppFactoryContract

SimpleAppContract

SimpleAppInitializerContract