@tangle-network/starter-foundry 0.1.0

package/registry/layers/capability/marketplace/files/listing-card.tsx

@@ -0,0 +1,80 @@
+import { Card, CardContent } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'
+import { Star, Clock, MapPin } from 'lucide-react'
+
+export interface Listing {
+  id: string
+  title: string
+  description: string
+  price: number
+  images: string[]
+  category: string
+  seller: {
+    name: string
+    avatar?: string
+    rating: number
+  }
+  location?: string
+  createdAt: string
+}
+
+function timeAgo(date: string): string {
+  const seconds = Math.floor((Date.now() - new Date(date).getTime()) / 1000)
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`
+  return `${Math.floor(seconds / 86400)}d ago`
+}
+
+export function ListingCard({ listing }: { listing: Listing }) {
+  const initials = listing.seller.name.slice(0, 2).toUpperCase()
+
+  return (
+    <Card className="group overflow-hidden transition-transform hover:scale-[1.02]">
+      <div className="relative aspect-[4/3] bg-gradient-to-br from-muted to-muted/50">
+        {listing.images[0] && (
+          <img
+            src={listing.images[0]}
+            alt={listing.title}
+            className="h-full w-full object-cover"
+          />
+        )}
+        <Badge className="absolute right-2 top-2 text-sm font-semibold">
+          ${listing.price.toLocaleString()}
+        </Badge>
+      </div>
+      <CardContent className="space-y-2 p-3">
+        <div className="flex items-center gap-1.5">
+          <Badge variant="secondary" className="text-xs">
+            {listing.category}
+          </Badge>
+          <span className="flex items-center gap-0.5 text-xs text-muted-foreground">
+            <Clock className="h-3 w-3" />
+            {timeAgo(listing.createdAt)}
+          </span>
+        </div>
+        <h3 className="line-clamp-1 font-semibold leading-tight">{listing.title}</h3>
+        <p className="line-clamp-2 text-sm text-muted-foreground">{listing.description}</p>
+        <div className="flex items-center justify-between pt-1">
+          <div className="flex items-center gap-1.5">
+            <Avatar className="h-5 w-5">
+              <AvatarImage src={listing.seller.avatar} />
+              <AvatarFallback className="text-[10px]">{initials}</AvatarFallback>
+            </Avatar>
+            <span className="text-xs text-muted-foreground">{listing.seller.name}</span>
+            <span className="flex items-center gap-0.5 text-xs text-amber-500">
+              <Star className="h-3 w-3 fill-current" />
+              {listing.seller.rating.toFixed(1)}
+            </span>
+          </div>
+          {listing.location && (
+            <span className="flex items-center gap-0.5 text-xs text-muted-foreground">
+              <MapPin className="h-3 w-3" />
+              {listing.location}
+            </span>
+          )}
+        </div>
+      </CardContent>
+    </Card>
+  )
+}

package/registry/layers/capability/marketplace/files/listing-grid.tsx

@@ -0,0 +1,55 @@
+import { Skeleton } from '@/components/ui/skeleton'
+import { ListingCard, type Listing } from './listing-card'
+import { PackageOpen } from 'lucide-react'
+
+interface ListingGridProps {
+  listings: Listing[]
+  isLoading?: boolean
+}
+
+function SkeletonCard() {
+  return (
+    <div className="space-y-3 rounded-lg border p-0">
+      <Skeleton className="aspect-[4/3] w-full rounded-b-none rounded-t-lg" />
+      <div className="space-y-2 px-3 pb-3">
+        <Skeleton className="h-4 w-20" />
+        <Skeleton className="h-5 w-3/4" />
+        <Skeleton className="h-4 w-full" />
+        <div className="flex items-center gap-2 pt-1">
+          <Skeleton className="h-5 w-5 rounded-full" />
+          <Skeleton className="h-3 w-24" />
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export function ListingGrid({ listings, isLoading }: ListingGridProps) {
+  if (isLoading) {
+    return (
+      <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
+        {Array.from({ length: 6 }).map((_, i) => (
+          <SkeletonCard key={i} />
+        ))}
+      </div>
+    )
+  }
+
+  if (listings.length === 0) {
+    return (
+      <div className="flex flex-col items-center justify-center gap-3 py-16 text-muted-foreground">
+        <PackageOpen className="h-12 w-12 stroke-1" />
+        <p className="text-lg font-medium">No listings found</p>
+        <p className="text-sm">Try adjusting your search or filters.</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
+      {listings.map((listing) => (
+        <ListingCard key={listing.id} listing={listing} />
+      ))}
+    </div>
+  )
+}

package/registry/layers/capability/marketplace/files/marketplace-config.json

@@ -0,0 +1,26 @@
+{
+  "categories": [
+    "Electronics",
+    "Home & Garden",
+    "Services",
+    "Vehicles",
+    "Fashion",
+    "Sports & Outdoors",
+    "Collectibles",
+    "Other"
+  ],
+  "sortOptions": ["newest", "price-low", "price-high", "rating"],
+  "listingStatuses": ["draft", "active", "sold", "archived"],
+  "pricing": {
+    "currency": "USD",
+    "minPrice": 0,
+    "maxPrice": 100000,
+    "platformFeePercent": 10
+  },
+  "features": {
+    "reviews": true,
+    "messaging": true,
+    "savedListings": true,
+    "sellerVerification": true
+  }
+}

package/registry/layers/capability/marketplace/files/review-card.tsx

@@ -0,0 +1,57 @@
+import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'
+import { Badge } from '@/components/ui/badge'
+import { Star } from 'lucide-react'
+
+interface Review {
+  id: string
+  rating: number
+  comment: string
+  reviewer: {
+    name: string
+    avatar?: string
+  }
+  verified?: boolean
+  createdAt: string
+}
+
+function Stars({ rating }: { rating: number }) {
+  return (
+    <div className="flex gap-0.5">
+      {Array.from({ length: 5 }).map((_, i) => (
+        <Star
+          key={i}
+          className={`h-4 w-4 ${i < rating ? 'fill-amber-500 text-amber-500' : 'text-muted-foreground/30'}`}
+        />
+      ))}
+    </div>
+  )
+}
+
+export function ReviewCard({ review }: { review: Review }) {
+  const initials = review.reviewer.name.slice(0, 2).toUpperCase()
+  const date = new Date(review.createdAt).toLocaleDateString(undefined, {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  })
+
+  return (
+    <div className="space-y-2 rounded-lg border p-4">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <Avatar className="h-7 w-7">
+            <AvatarImage src={review.reviewer.avatar} />
+            <AvatarFallback className="text-xs">{initials}</AvatarFallback>
+          </Avatar>
+          <span className="text-sm font-medium">{review.reviewer.name}</span>
+          {review.verified && (
+            <Badge variant="secondary" className="text-[10px]">Verified Purchase</Badge>
+          )}
+        </div>
+        <span className="text-xs text-muted-foreground">{date}</span>
+      </div>
+      <Stars rating={review.rating} />
+      <p className="text-sm text-muted-foreground">{review.comment}</p>
+    </div>
+  )
+}

package/registry/layers/capability/marketplace/files/search-filters.tsx

@@ -0,0 +1,113 @@
+'use client'
+
+import { useState } from 'react'
+import { Input } from '@/components/ui/input'
+import { Button } from '@/components/ui/button'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select'
+import { Separator } from '@/components/ui/separator'
+import { Search, X } from 'lucide-react'
+
+export interface SearchFiltersState {
+  query: string
+  category: string
+  minPrice: string
+  maxPrice: string
+  sort: string
+}
+
+const defaultFilters: SearchFiltersState = {
+  query: '',
+  category: '',
+  minPrice: '',
+  maxPrice: '',
+  sort: 'newest',
+}
+
+interface SearchFiltersProps {
+  onFilter: (filters: SearchFiltersState) => void
+  categories: string[]
+  initialFilters?: Partial<SearchFiltersState>
+}
+
+export function SearchFilters({ onFilter, categories, initialFilters }: SearchFiltersProps) {
+  const [filters, setFilters] = useState<SearchFiltersState>({
+    ...defaultFilters,
+    ...initialFilters,
+  })
+
+  const update = (patch: Partial<SearchFiltersState>) => {
+    const next = { ...filters, ...patch }
+    setFilters(next)
+    onFilter(next)
+  }
+
+  const clear = () => {
+    setFilters(defaultFilters)
+    onFilter(defaultFilters)
+  }
+
+  const hasFilters = filters.query || filters.category || filters.minPrice || filters.maxPrice || filters.sort !== 'newest'
+
+  return (
+    <div className="sticky top-0 z-10 flex flex-wrap items-center gap-2 rounded-lg border bg-background/95 p-3 backdrop-blur supports-[backdrop-filter]:bg-background/60">
+      <div className="relative flex-1 min-w-[200px]">
+        <Search className="absolute left-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+        <Input
+          placeholder="Search listings..."
+          value={filters.query}
+          onChange={(e) => update({ query: e.target.value })}
+          className="pl-8"
+        />
+      </div>
+      <Select value={filters.category} onValueChange={(v) => update({ category: v })}>
+        <SelectTrigger className="w-[160px]">
+          <SelectValue placeholder="Category" />
+        </SelectTrigger>
+        <SelectContent>
+          {categories.map((cat) => (
+            <SelectItem key={cat} value={cat}>{cat}</SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+      <Separator orientation="vertical" className="h-8" />
+      <Input
+        type="number"
+        placeholder="Min $"
+        value={filters.minPrice}
+        onChange={(e) => update({ minPrice: e.target.value })}
+        className="w-[100px]"
+      />
+      <Input
+        type="number"
+        placeholder="Max $"
+        value={filters.maxPrice}
+        onChange={(e) => update({ maxPrice: e.target.value })}
+        className="w-[100px]"
+      />
+      <Separator orientation="vertical" className="h-8" />
+      <Select value={filters.sort} onValueChange={(v) => update({ sort: v })}>
+        <SelectTrigger className="w-[140px]">
+          <SelectValue placeholder="Sort by" />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="newest">Newest</SelectItem>
+          <SelectItem value="price-low">Price: Low</SelectItem>
+          <SelectItem value="price-high">Price: High</SelectItem>
+          <SelectItem value="rating">Top Rated</SelectItem>
+        </SelectContent>
+      </Select>
+      {hasFilters && (
+        <Button variant="ghost" size="sm" onClick={clear}>
+          <X className="mr-1 h-3 w-3" />
+          Clear
+        </Button>
+      )}
+    </div>
+  )
+}

package/registry/layers/capability/marketplace/manifest.json

@@ -0,0 +1,29 @@
+{
+  "id": "marketplace",
+  "description": "Two-sided marketplace with listings, search, user roles (buyer/seller), reviews, and payment integration.",
+  "group": "capability",
+  "appliesTo": ["nextjs-ts", "react-vite-ts", "fullstack-ts"],
+  "keywords": ["marketplace", "listings", "buyer", "seller", "two-sided", "peer to peer", "p2p", "gig", "freelance", "rental", "booking", "auction", "classified"],
+  "files": [
+    { "source": "files/marketplace-config.json", "target": "marketplace-config.json" },
+    { "source": "files/listing-card.tsx", "target": "src/components/marketplace/listing-card.tsx" },
+    { "source": "files/listing-grid.tsx", "target": "src/components/marketplace/listing-grid.tsx" },
+    { "source": "files/search-filters.tsx", "target": "src/components/marketplace/search-filters.tsx" },
+    { "source": "files/review-card.tsx", "target": "src/components/marketplace/review-card.tsx" }
+  ],
+  "buildHints": {
+    "pages": ["/", "/listings", "/listings/[id]", "/dashboard/seller", "/dashboard/buyer"],
+    "apiRoutes": ["/api/listings", "/api/listings/[id]", "/api/reviews", "/api/search"],
+    "components": ["ListingCard", "ListingGrid", "SearchFilters", "ReviewCard", "SellerDashboard", "BuyerDashboard"],
+    "dataModels": ["Listing { id, title, description, price, images, sellerId, category, status }", "Review { id, listingId, buyerId, rating, comment }", "Order { id, listingId, buyerId, status, total }"],
+    "integrations": ["Stripe Connect for marketplace payments", "Full-text search (Algolia, Meilisearch, or pg_trgm)", "Image upload (S3, Cloudflare R2, or Uploadthing)"],
+    "architectureNotes": [
+      "ListingGrid renders a responsive grid of ListingCards with search and category filters.",
+      "SearchFilters provides category dropdown, price range slider, sort order, and text search.",
+      "ReviewCard displays star rating, reviewer info, and comment with timestamp.",
+      "Seller dashboard shows active listings, orders, and revenue metrics.",
+      "Buyer dashboard shows purchase history, saved listings, and pending reviews.",
+      "Wire Stripe Connect for split payments between platform and sellers."
+    ]
+  }
+}

package/registry/layers/capability/move-amm/files/amm-config.json

@@ -0,0 +1 @@
+{ "model": "constant-product", "features": ["create-pool", "add-liquidity", "remove-liquidity", "swap", "multi-hop-routing"], "feeConfig": { "swapFeeBps": 30, "protocolFeeBps": 5 }, "notes": ["Pool math uses x*y=k constant product formula.", "LP tokens represent proportional pool ownership.", "Multi-hop routing finds the best path across multiple pools."] }

package/registry/layers/capability/move-amm/manifest.json

@@ -0,0 +1,46 @@
+{
+  "id": "move-amm",
+  "description": "Adds AMM/DEX patterns for Move/Aptos with pool math and routing.",
+  "appliesTo": [
+    "move-contracts"
+  ],
+  "files": [
+    {
+      "source": "files/amm-config.json",
+      "target": "amm-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "amm-config.json"
+    ]
+  },
+  "keywords": [
+    "move amm",
+    "aptos dex",
+    "move swap",
+    "liquidity pool aptos",
+    "move defi",
+    "dex",
+    "swap",
+    "amm",
+    "move dex",
+    "aptos swap"
+  ],
+  "buildHints": {
+    "components": [
+      "PoolModule",
+      "SwapRouter",
+      "LPToken"
+    ],
+    "dataModels": [
+      "Pool",
+      "Position",
+      "SwapRoute"
+    ],
+    "integrations": [
+      "Constant product AMM",
+      "Multi-hop routing"
+    ]
+  }
+}

package/registry/layers/capability/move-launchpad/files/launchpad-config.json

@@ -0,0 +1 @@
+{ "saleTypes": ["fixed-price", "dutch-auction", "overflow"], "features": ["whitelist", "vesting", "anti-snipe", "refund"], "vestingSchedule": { "cliff": "30d", "duration": "180d", "linear": true }, "notes": ["Support multiple sale types per launchpad.", "Anti-snipe mechanism delays final allocation.", "Vesting uses Move's timestamp module for on-chain enforcement."] }

package/registry/layers/capability/move-launchpad/manifest.json

@@ -0,0 +1,45 @@
+{
+  "id": "move-launchpad",
+  "description": "Adds token launchpad patterns for Move/Aptos with sale types and vesting.",
+  "appliesTo": [
+    "move-contracts"
+  ],
+  "files": [
+    {
+      "source": "files/launchpad-config.json",
+      "target": "launchpad-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "launchpad-config.json"
+    ]
+  },
+  "keywords": [
+    "move launchpad",
+    "aptos launchpad",
+    "token sale aptos",
+    "fair launch aptos",
+    "ido aptos",
+    "launchpad",
+    "token sale",
+    "fair launch"
+  ],
+  "buildHints": {
+    "components": [
+      "SaleModule",
+      "VestingModule",
+      "WhitelistModule"
+    ],
+    "dataModels": [
+      "Sale",
+      "Allocation",
+      "VestingSchedule"
+    ],
+    "integrations": [
+      "Fixed-price sale",
+      "Dutch auction",
+      "Linear vesting"
+    ]
+  }
+}

package/registry/layers/capability/move-nft/files/nft-config.json

@@ -0,0 +1 @@
+{ "standard": "aptos-token-v2", "features": ["create-collection", "mint", "list", "buy", "auction", "royalty-enforcement"], "notes": ["Use Aptos Token V2 standard for composable digital assets.", "Royalty enforcement is on-chain via the token standard.", "Auction module supports English and Dutch auction types."] }

package/registry/layers/capability/move-nft/manifest.json

@@ -0,0 +1,9 @@
+{
+  "id": "move-nft",
+  "description": "Adds NFT collection and marketplace patterns for Move/Aptos.",
+  "appliesTo": ["move-contracts"],
+  "files": [{ "source": "files/nft-config.json", "target": "nft-config.json" }],
+  "contextHints": { "extensionPoints": ["nft-config.json"] },
+  "keywords": ["move nft", "aptos nft", "nft marketplace", "nft collection", "digital asset"],
+  "buildHints": { "components": ["CollectionManager", "ListingModule", "AuctionModule"], "dataModels": ["Collection", "Token", "Listing", "Bid"], "integrations": ["Aptos Token V2 standard"] }
+}

package/registry/layers/capability/move-oracle/files/oracle-config.json

@@ -0,0 +1 @@
+{ "oracleType": "{{oracleType}}", "sources": ["pyth", "switchboard"], "aggregation": "weighted-median", "updateFrequency": "1s", "notes": ["Implement oracle module in sources/ with multi-source aggregation.", "Use weighted median for tamper resistance.", "Pyth and Switchboard both have Aptos SDKs."] }

package/registry/layers/capability/move-oracle/manifest.json

@@ -0,0 +1,10 @@
+{
+  "id": "move-oracle",
+  "description": "Adds oracle data feed patterns for Move/Aptos with multi-source aggregation.",
+  "appliesTo": ["move-contracts"],
+  "defaults": { "oracleType": "price-feed" },
+  "files": [{ "source": "files/oracle-config.json", "target": "oracle-config.json" }],
+  "contextHints": { "extensionPoints": ["oracle-config.json", "sources/"] },
+  "keywords": ["move oracle", "aptos oracle", "price feed", "pyth aptos", "switchboard aptos"],
+  "buildHints": { "components": ["PriceFeed", "OracleAggregator"], "dataModels": ["PriceData", "FeedSource"], "integrations": ["Pyth Network", "Switchboard"] }
+}

package/registry/layers/capability/move-staking/files/staking-config.json

@@ -0,0 +1 @@
+{ "features": ["stake", "unstake", "claim-rewards", "boost", "delegation"], "rewardModel": "proportional", "unstakingPeriod": "7d", "notes": ["Reward distribution is proportional to stake weight.", "Boost multipliers incentivize longer lock periods.", "Unstaking period enforced on-chain via timestamp module."] }

package/registry/layers/capability/move-staking/manifest.json

@@ -0,0 +1,9 @@
+{
+  "id": "move-staking",
+  "description": "Adds staking and rewards distribution patterns for Move/Aptos.",
+  "appliesTo": ["move-contracts"],
+  "files": [{ "source": "files/staking-config.json", "target": "staking-config.json" }],
+  "contextHints": { "extensionPoints": ["staking-config.json"] },
+  "keywords": ["move staking", "aptos staking", "staking rewards aptos", "validator delegation aptos"],
+  "buildHints": { "components": ["StakePool", "RewardDistributor", "BoostModule"], "dataModels": ["Stake", "Reward", "BoostMultiplier"], "integrations": ["Reward distribution", "Delegation", "Boost multipliers"] }
+}

package/registry/layers/capability/realtime-ws/files/realtime-config.json

@@ -0,0 +1,19 @@
+{
+  "heartbeatMs": "{{wsHeartbeatMs}}",
+  "maxConnections": "{{wsMaxConnections}}",
+  "rooms": true,
+  "presence": true,
+  "channels": ["default"],
+  "events": {
+    "join": "room:join",
+    "leave": "room:leave",
+    "message": "room:message",
+    "presence": "room:presence"
+  },
+  "reconnect": {
+    "enabled": true,
+    "maxRetries": 5,
+    "backoffMs": 1000,
+    "maxBackoffMs": 30000
+  }
+}

package/registry/layers/capability/realtime-ws/files/ws-client.ts

@@ -0,0 +1,90 @@
+import { useEffect, useRef, useCallback, useState } from 'react'
+import type { WSMessage } from './ws-types'
+
+type Handler = (data: unknown) => void
+
+interface UseWebSocketOptions {
+  autoReconnect?: boolean
+  maxRetries?: number
+}
+
+interface UseWebSocketReturn {
+  sendMessage: (event: string, data: unknown, room?: string) => void
+  lastMessage: WSMessage | null
+  readyState: number
+  subscribe: (event: string, handler: Handler) => () => void
+}
+
+export function useWebSocket(url: string, options: UseWebSocketOptions = {}): UseWebSocketReturn {
+  const { autoReconnect = true, maxRetries = 5 } = options
+  const wsRef = useRef<WebSocket | null>(null)
+  const handlersRef = useRef(new Map<string, Set<Handler>>())
+  const retriesRef = useRef(0)
+  const [readyState, setReadyState] = useState<number>(WebSocket.CLOSED)
+  const [lastMessage, setLastMessage] = useState<WSMessage | null>(null)
+  const unmountedRef = useRef(false)
+
+  const connect = useCallback(() => {
+    if (unmountedRef.current) return
+    const ws = new WebSocket(url)
+    wsRef.current = ws
+
+    ws.onopen = () => {
+      if (unmountedRef.current) return
+      retriesRef.current = 0
+      setReadyState(WebSocket.OPEN)
+    }
+
+    ws.onclose = () => {
+      if (unmountedRef.current) return
+      setReadyState(WebSocket.CLOSED)
+      if (autoReconnect && retriesRef.current < maxRetries) {
+        const delay = Math.min(1000 * 2 ** retriesRef.current, 30_000)
+        retriesRef.current++
+        setTimeout(connect, delay)
+      }
+    }
+
+    ws.onerror = () => {
+      ws.close()
+    }
+
+    ws.onmessage = (e) => {
+      if (unmountedRef.current) return
+      try {
+        const msg: WSMessage = JSON.parse(e.data as string)
+        setLastMessage(msg)
+        const eventHandlers = handlersRef.current.get(msg.event)
+        if (eventHandlers) {
+          for (const h of eventHandlers) h(msg.data)
+        }
+      } catch { /* ignore malformed */ }
+    }
+  }, [url, autoReconnect, maxRetries])
+
+  useEffect(() => {
+    unmountedRef.current = false
+    connect()
+    return () => {
+      unmountedRef.current = true
+      wsRef.current?.close()
+    }
+  }, [connect])
+
+  const sendMessage = useCallback((event: string, data: unknown, room?: string) => {
+    if (wsRef.current?.readyState === WebSocket.OPEN) {
+      const msg: WSMessage = { event, data, room }
+      wsRef.current.send(JSON.stringify(msg))
+    }
+  }, [])
+
+  const subscribe = useCallback((event: string, handler: Handler) => {
+    if (!handlersRef.current.has(event)) handlersRef.current.set(event, new Set())
+    handlersRef.current.get(event)!.add(handler)
+    return () => {
+      handlersRef.current.get(event)?.delete(handler)
+    }
+  }, [])
+
+  return { sendMessage, lastMessage, readyState, subscribe }
+}