Github

Next.js frontend for the Sproutly dashboard: the central portal for the Sproutly ecosystem (technology & community layer). Features: wallet connection via Reown AppKit (Wagmi) and VeChain dApp Kit; wallet linking and auth (cookies, social login). Game Hub: COMPOST balance, XP/levels, weekly allocations, voting, impact wallet, harvest grid; integration with Sproutly/VeChain RPC and Game API. NFT inventory (VeChain and other collections), NFTree cultivation/upgrades, ecosystem tiers, and marketplace (listings, bids). Staking (single-sided, tier, tree staking), CO₂ management (footprint, sCO₂ trade, certificates), and governance (DAO proposals, treasury). Impact map (Mapbox): tree locations, clusters, satellite styles; optional Leaflet. Leaderboard, referral program, swap portal, Sproutly bridge; admin panel for designated wallets. Pixi.js game demo; Chart.js for dashboard metrics; MUI + Tailwind + Emotion for UI. Tech: Next.js 15 (App Router), React 19, TypeScript, Redux (RTK), TanStack Query, ethers, viem.

React/Vite admin portal for the Climate Cooperative ecosystem: internal dashboard for portfolio and geo-tracking of tree-planting systems (Brazil & Angola). Features: highlight strip (geo counts, portfolio split Climate Cooperative vs Sproutly); Mapbox map with RioTerra GeoJSON (clusters, points, heatmap), satellite styles and historical capture slider (2019–2025); portfolio panel (country comparison, CO₂ kg, value €/$, breakdowns and projections); on-chain batch management (15 batch contracts on Polygon, mint tables with CO₂ and value); top wallets per batch and holders of carbon reduction certificates via Covalent API; CRC mint events and metadata (CloudFront); CO₂ extraction from NFT metadata. Scripts: fetch-metadata (cache CRC metadata), csv-to-geojson (RioTerra). Provides login and overview for 711k+ geo locations. Tech: Vite 7, React 19, Mapbox GL, vanilla CSS.

Node.js/Express backend that converts Sproutly game events into on-chain score submissions for N3MUS tournaments. Exposes an N3MUS-compatible POST /postMatchResults endpoint (and alias POST /api/postMatchResults) to the Match Scores smart contract on Moonbeam. Features: API key auth; rate limiting (stricter for match submissions); request validation (Zod) and request size limits; idempotency via eventId; structured logging (Winston); ethers v6 and startup sanity checks (RPC, chain ID, wallet balance, contract); health endpoints /healthz and /readyz; Docker (multi-stage build). Tech: Node.js 20+, Express, TypeScript, ethers v6, Zod, Winston, Helmet.

Node.js/Express backend that exposes Sproutly game and dashboard statistics as a JSON/HTTP API. Reads from Parse Server (via dashboard/lib/* and xp-stats.js) and serves aggregates on authenticated routes. Features: session auth (POST /login, POST /logout) and API access via session, Basic Auth, or API key; all /api/* endpoints protected with session or API auth. API: summary stats (active users, health, logins, memory/load), XP export per player (JSON/CSV, optional orchards and date filters), leaderboards (weekly, monthly, all-time), revenue stats, orchards list, user export (all users, single summary, orchard, tree purchases), item stats (last 30 days + current snapshot), tree stats snapshot. Rate limiting (stricter on login and sensitive endpoints). Public status page (GET /status) with endpoint health checks. HTML dashboard and login page served after auth. Scripts: transaction Discord notifier (Parse transaction events → webhook), dump Parse schema. CORS for dashboard and game origins. Tech: Node.js, Express 5, express-session, express-rate-limit, Parse (parse/node), envalid.

Next.js admin panel for the Climate Cooperative ecosystem: internal dashboard for $aCO2, certificates, CO₂ pools, staking and token issuance. Features: wallet connection via Web3Modal (Wagmi) with cookie persistence on Polygon, Base Sepolia and Mainnet; Send Tokens – ERC-20 ($CBY), ERC-721 (NFTrees, 13 batches), ERC-1155 ($aCO2, Discord NFTs); CO₂ pools – create, edit, list and withdraw; Certificates – mint (main and sub-certificates), burn $aCO2, certificate overview; Staking – manage staking pool; Business Portal – orders and data (b2b trees); Overview – admin wallet metrics ($aCO2 total/pending/claimed/generated), purchases (registry.globalcarbonstandard.org), certificates, b2b/b2c trees sold, $aCO2 per segment (b2b/b2c/staking/regular), NFTree batches (e.g. Genesis), carbon debits, top holders; Batch Minting – mint batches. Integration with Climate Cooperative, Climate Cooperative NFT, Climate Cooperative Assets, ACO2 and Airdrop contracts; role-based access (Climate Cooperative admin role). Auth: signin, signup, reset password, two-step verification. UI: MUI, Tailwind, Emotion, ApexCharts, flatpickr, react-toastify. Tech: Next.js 14 (App Router), React 18, TypeScript, Redux (RTK), TanStack Query, ethers v5, viem, Wagmi.

Solidity/Hardhat repository for the Climate Cooperative and Sproutly smart contract suite: multichain (Wormhole) deployment, upgradeable (UUPS) patterns, and OpenZeppelin v4/v5. Core: aCO2 (ERC1155) with batch/claim/merkle logic; Nftree (ERC721/ERC721A) batches and soulbound/migrated variants; Landplots (standard, V3, V5) with plot capacity; Staking (lock CBY, stake trees on plots, claim aCO2 via StakingPool); aCO2Pool (exchange aCO2 for ERC20, donation/opposite pools); Climate Cooperative Community Marketplace (listings, bids, ERC20/ERC1155 payment, Wormhole NFTREE support); CarbonCertificate (ERC721 CRC); CBY and SEED (ERC20, mintable/bridged variants); COMPOST and CompostMinter (caps, idempotency, backend signer). Sproutly: Governor and Timelock; ImpactVotingPower (aCO2 burn → votes, seasons); SeedStakingTiers; TokenVesting (lock X, reward Y, CalculationLayer); bridge (Vault, VaultUnlimited, CbyWormholeBridge). Cross-chain: Climate Cooperative Hub (WormholeReceiver, tree ownership, aCO2 claims); NftreeV2 and aCO2TokenV2 (Wormhole); WormholeUtils. Other: OGBadge (ERC721A); BatchTransferNFT; compost-setup (Compost NFT, cCO2Token). Deploy configs and scripts: deployment, migration, bridge, staking, certificate redistribution, pending rewards, B2B batches, OG badges, crosschain tooling. Deployments target Polygon, Base, Moonbeam, Sepolia, and other EVM chains. Tech: Solidity 0.8.x, Hardhat, OpenZeppelin Contracts (upgradeable), ERC721A, Wormhole relayer/receiver interfaces.

Node.js/Express backend for the Sproutly/Climate Cooperative dashboard: users, purchases, certificate requests and profiles as a JSON/HTTP API. Auth via PASETO (access/refresh) in cookies; session-based routes protected with authenticateToken. Auth: register, login, logout, refresh token, token verification, forgot password (confirm flow), two-step verification (2FA generate/verify), force logout; admin login and verification separate. API: /api/v1/auth (register, login, forgot-password, 2FA, refresh, verify, logout), /api/v1/purchase (create purchase; purchase-data admin-only), /api/v1/user-profile (logged-in user: profile, update with profile photo, delete account, wallet linking, certificate requests, disable notifications), /api/v1/admin (all users, single user, grant admin, update linked wallet, certificate requests CRUD). User profile: profile photo upload to AWS S3 (multer-s3), multiple wallets (main, VeChain, Incentiv) with link/check/verify; wallet addresses validated with ethers. Certificate requests: user requests (create, own overview, delete); admin: overview, pending, update, delete. Roles: user, admin, mainAdmin; userRoleValidation on admin routes. Rate limiting on login, register, forgot-password, purchase and user-profile (e.g. delete-account strict). Security: Helmet, CORS, express-mongo-sanitize, XSS sanitization on body, cookie-parser. Email via Resend (forgot-password, 2FA). Data: Mongoose models User (username, email, country, password, role, linked_wallet, additional_wallets, 2FA, thalliumBalance, notifications), Purchase, CertificateRequest, Pack, ExchangeTransaction. Scripts: build (tsc), start, dev (tsc watch + nodemon), test (Jest), plus seed script for Packs (seedPacks). Tech: Node.js, Express 4, TypeScript, Mongoose, PASETO (v4), bcrypt, Resend, AWS SDK (S3), multer, multer-s3, ethers, express-rate-limit, helmet, cookie-parser, envalid.

Next.js business portal for the Climate Cooperative ecosystem: customer-facing dashboard for Carbon Debits (CO₂), carbon offset certificates, Impact Systems (trees) and impact reporting. Features: Overview – chart (Chart.js), action table with filters, Mapbox map with tree clusters; CO₂ Balance – available balance, Create Carbon Offset Certificate, Buy Carbon Debits (tons, Stripe checkout), Buy Impact Systems, transaction log; Certificates – table with search, quick filters (My certificates, This year, Last 30 days), PDF/Metadata per row, row selection with action bar (View certificate, Download, Open on map), certificate detail page, Mapbox map for selected cert trees; Trees – table (ID, geo location with copy, species, country), Map column (View on map), row click or View on map centres map with pin and info popup, bulk selection toolbar (Clear selection, Select all, Batch), More filters (country, species); Transfers – tabs (Certificates, Trees, Carbon Debits), per-type modals with recipient email validation, Transfers are permanent warning, certificate dropdown (number, date, kg CO₂), primary Transfer and Cancel; Impact Reports – CSV export (impact systems, certificates), PDF (CSRD-aligned Impact Statement, year selector, last generated), CO₂ overview (balance, retired 12m, certificates, kg), Portfolio Impact (area m², food kg, work FTE, communities), SDG section; FAQ – search, accordion, Book a call (Calendly), Contact support; Calculator – multi-step footprint (house, air, transport, etc.), result view; External tree map – public page per certificate with map and company info. Integration with Climate Cooperative backend API (cookie auth), Stripe (Payment Intents), Mapbox, Calendly; optional Web3Auth and viem for wallet/chain (Polygon, Base Sepolia) and transfer/claim flows. Auth: signin, signup, forgot/reset password, two-factor verification. UI: MUI (Collapse, Table, Dialog, etc.), Tailwind CSS, Emotion, react-icons, next/image. Tech: Next.js 14 (App Router), React 18, JavaScript (JSX), React Context and useReducer, React Hook Form, Axios, jspdf (CSRD PDF), react-calendly, sharp.

Node.js backend for generating and managing Climate Cooperative/Sproutly certificates (aCO2/CRC): API for certificate requests from the dashboard, generation of certificate metadata and images, and integration with CarbonCertificate (ERC721 CRC) and aCO2 logic. Features: certificate generation (metadata, base images, variants such as Zello Green); integration with carbify-dashboard-backend for certificate requests; optional PDF or asset export; deployment and migration scripts. Purpose: backend for Carbon Removal Certificates (CRC) and aCO2-related certificates in the Climate Cooperative ecosystem. Tech: Node.js, TypeScript, likely Express or Fastify, integration with smart contracts (carbify-smart-contracts) and dashboard API.

Node.js/Express backend for the Climate Cooperative portal: users, offset and aCO2 requests, tree purchases, certificates and profiles as JSON/HTTP API. Auth via PASETO v4 (access/refresh) in cookies; optional x-api-key (Offsets). Auth: register, login, logout, refresh, 2FA, forgot-password, JWKS (.well-known/jwks.json), Web3 JWT (RS256) for wallet integration. API: /api/v1/auth (register, login, 2FA, refresh, verify, logout), /api/v1/user-profile (profile, offset/buyco2/buy-tree requests, certificates, aCO2, Stripe Payment Intent, transfers, API keys), /api/v1/admin (users, grant admin, offset/buyco2/buy-tree requests CRUD, certificates, dashboard certificate requests). Roles: user, admin, mainAdmin. Rate limiting on login, register, forgot-password. Security: Helmet, CORS, sanitize, cookie-parser. Email via Resend. Data: Mongoose (User, OffsetRequest, BuyCo2Order, BuyTreeOrder, B2bTrees) in Portal-DB; MongoClient to Dashboard-DB and Carbify-DB. Scripts: build, start, dev, test, stripe:test. Tech: Node.js, Express 4, TypeScript, Mongoose, PASETO v4, bcrypt, Resend, Stripe, jsonwebtoken, express-rate-limit, helmet.

React SPA for the Sproutly/Climate Cooperative user dashboard: login, profile, wallet linking, NFTrees/plots, staking, aCO2 pools, marketplace, carbon calculator and certificate generation. Communicates with dashboard-backend (cookie auth) and multiple APIs (Web3, aCO2, CRC, listings, purchase). Routes: public (/, login, register, forgot/reset password, 2FA, carbon-footprint-calculator); after login (connect-wallet); after wallet (dashboard, nfts, nftrees, plots, staking, marketplace, aCO2-pools, carbon-calculator, profile, certificates, listing). Auth: register, login, logout, verify-token, forgot-password, 2FA (TOTP via API); session via cookies. Protected routes: AuthenticatedRoutes (token + 2FA), WalletAddressRoutes (wallet must be linked). User profile: get/update (multipart photo), delete account, wallet link/check/verify. Wallet: wagmi (WalletConnect, Coinbase), Polygon and Polygon Amoy. Dashboard: tree/plot balances, CBY price, staking rewards, Carbon Certificate card (burn aCO2, CRC API), Claim aCO2, line chart. NFTrees/Plots: per asset contract, stake/unstake trees, lock/unlock CBY, marketplace listings and purchase. aCO2-pools: approve/sell/withdraw. Carbon calculator: footprint (e.g. flights via Carbon Interface API); public variant without login. Certificates: generation via CRC API (burn amount, title, reason, date); certificates page currently disabled. State: Redux (auth, user, wallet, staking, marketplace, aCO2, CBY price, alerts, footprint, OTP); TanStack Query for server state. Scripts: start, build, test, sentry:sourcemaps. Tech: React 18, React Router 6, Redux Toolkit, TanStack Query, Axios, wagmi, viem, ethers, Web3Modal, Chart.js, Tailwind CSS, react-toastify, dayjs, qrcode, js-cookie, Sentry.

Node.js/Express backend for the Climate Cooperative dashboard: fetches and serves Web3 data (smart contracts, subgraphs, wallets) as a REST API. Pulls data via The Graph subgraphs and direct contract calls (including multicall), combines with MongoDB and returns it aggregated to the dashboard frontend. Features: ERC721 – tokens per wallet with pagination (pageKey, amount), filter by contract and listed status; token count per wallet/contract; metadata via tokenURI (IPFS/Pinata); fallback to second ERC721 subgraph when empty. aCO2 – aCO2 tokens per wallet (batchAddresses/batchStartId via multicall), aCO2 token count (ERC1155 subgraph). ERC1155 – tokens per wallet with pagination; filter balance > 0; metadata via uri and IPFS (w3s.link); burned tokens per wallet. Staking/Merkle – merkle proofs non-staked (MongoDB MerkelProofNonStake, isClaimedBatch multicall); staked rewards (MongoDB MerkelProofStake, claim_objects). CBY – balance (ERC20), price (staking contract getPrice), historical chart (CoinMarketCap API, 14 days). Marketplace – NFT listings (subgraph), per listing or first 1000; NFT offers per listing (sorted by totalOfferAmount); metadata for NFTree/CarbifyNFT; staking/locked CBY for listing detail. aCO2 Pools – pools (subgraph: exchange rates, caps, expireDate, isFilled); user claims per wallet; pool logos in MongoDB. Caching: node-cache for subgraph responses. Rate limiting: 429 from subgraph handled with retry after retry-after. Environments: development (Mumbai, dev DB), production (Polygon, prod DB). Deploy: AWS App Runner (dev/stage/master). Used by Climate Cooperative dashboard (React) for wallet overviews, aCO2 tokens, trees (NFTs), staking, CBY balance/price, marketplace listings and aCO2 pools; works alongside a separate User Data API for auth. Tech: Node.js, Express 4, JavaScript, Web3 1.10, Axios, MongoDB (native driver), node-cache, @dopex-io/web3-multicall, AWS SDK, cors, morgan. Scripts: start (dev), dev (nodemon), start-prod.

Monorepo of The Graph subgraphs for the Sproutly/Climate Cooperative ecosystem. Indexes on-chain data from smart contracts and serves it via GraphQL to carbify-web3-api (and thus the dashboard) for NFTrees, plots, staking, marketplace, aCO2 tokens and aCO2 pools. Subgraphs: carbify-erc721-subgraph – ERC721 (Wallets, Tokens, Listings, Batch/BatchBalance); indexes Nftree (B1–B15), StakingNftree (SB1–SB15), Landplots (standard, V3, V5), Staking (Staked/Unstaked, Locked/Unlocked CBY), aCO2Token, CarbifyCommunityMarketplaceNoCC; Token entity (tokenId, owner, contractAddress, earnRate, isStaked, isListed, etc.); networks Polygon, Moonbeam, Polygon Amoy, Base Sepolia, Moonbase, sproutly-testnet. carbify-erc1155-subgraph – ERC1155 (Wallet, Token, WalletTokenBalance, BurnedToken, Listing); indexes aCO2Token via TransferSingle/TransferBatch. carbify-marketplace-subgraph – Marketplace (Listing, Offer, BestOffer; ListingAdded/Updated/Removed, NewOffer); two data sources (Marketplace, MarketplaceNoCC); networks Polygon, Moonbeam, Base Sepolia, Moonbase, sproutly-testnet. carbify-aco2pools-subgraph – aCO2 pools (Pool, UserClaim, deposits, PoolFill, withdrawals; PoolCreated, aCO2Deposited, PoolFilled, etc.; specVersion 1.0.0, prune auto). carbify-community-marketplace-subgraph – Community marketplace (Listing, Bid, User; ListingCreated, ListingClosed). Deploy: per subgraph via Graph Studio (graph auth --studio); scripts codegen, build, deploy-prod, deploy-dev, deploy-local; environment by copying subgraph.[environment].yaml to subgraph.yaml. Data from these subgraphs is consumed by carbify-web3-api for the dashboard. Tech: The Graph (graph-cli 0.69.2, graph-ts), AssemblyScript, matchstick-as for tests; each subgraph has its own package.json.

React SPA for the Climate Cooperative bridge (Carbibridge): cross-chain token and NFT transfers via the Wormhole network. Fork of the Wormhole Portal bridge, customised for Climate Cooperative (CBY token, Hello Wormhole contracts). Supports multiple source and destination chains with wallet connection per chain. No login; session is wallet-based. Routes: /transfer (default), /nft, /redeem (recovery for incomplete transfers), /usdc (Circle USDC bridge with relayer), /register (Attest – token registration on target chain), /nft-origin-verifier, /token-origin-verifier, /withdraw-tokens-terra, /unwrap-native. Wallet providers (contexts): Solana, Ethereum (EVM), Terra, Algorand, Xpla, Aptos, Injective, Near, Sei, Sui – each with connect dialog and key/balance display. Transfer flow: pick source chain and token, amount, destination chain and address; optional relayer (Acala or generic) for auto redeem; sign → fetch VAA from Guardian API → redeem on destination. NFT flow: source/dest chain, pick NFT, destination address, transfer and redeem. USDC: Circle bridge with relayer fee, approve/transfer/swap to native and redeem. Recovery: load existing signed VAA and redeem on destination (manual or via relayer). Attest: register token on another chain (create wrapped asset) via Wormhole. State: Redux (attest, nft, transfer, tokens, fee, usdc); DataWrapper for async. Wormhole: Guardian RPC for VAAs; optional relayer API. Chains (mainnet): Ethereum, Polygon, Moonbeam (config in consts; testnet: Goerli, Mumbai). Climate Cooperative custom: CUSTOMISED_CONTRACTS for CBY (ETH, Polygon, Moonbeam) and Hello Wormhole (ETH↔Polygon, Polygon↔Moonbeam); Carbibridge branding, links to carbify.io, dashboard, docs. Scripts: start (react-app-rewired), build (with --max_old_space_size=6144), test. Deploy: Vercel (build on main_build branch). Tech: React 17, React Router 5, Redux Toolkit, Material-UI 4, HashRouter, notistack, recharts, axios, @certusone/wormhole-sdk; chain-specific: ethers, @solana/web3.js, Terra, near-api-js, algosdk, aptos, Injective, Sei, Sui, Xpla, etc.

React/TypeScript frontend for the Global Carbon Registry: manage and display carbon projects (properties), carbon debits and co-transactions. Data from an external REST API. Properties: projects with name, proponent, type, country, region, plot/system size, carbon-debit fields (per year, generated, spent, available), batch fields (batchNumber, initialSupply, plantTime, etc.), documents (imageUrl, check, version, sign, initial, final, other) via upload to /api/upload, and optional read-only fields via contract address and fetch. List view: homepage with pagination, sorting and filters (proponent, name, type, country, region, isPublish), card/table view, totals Carbon Debits Issued and CO₂ offset. Co-trans: transactions with carbonCertificateId, aCO2Id, treeId, projectId, amount, txHash, geoLocation; filters and sorting; detail with total carbon spent; CSV export with date range and optional project id. Admin: cookie auth against /api/post/, login via /api/post/login/; manage routes /manage, /add, /manage-detail/:id, /change-item/:id; CRUD plus delete/duplicate project, delete files. Tech: React 18, TypeScript, CRA, React Router 6, Ant Design 5, Tailwind, Axios, react-cookie, react-toastify, react-csv-downloader, dayjs, countries-list. Scripts: start, build, test, eject.

Data-only repository with structured JSON for the Sproutly/Climate Cooperative ecosystem. Holds migration and configuration data for AWS App Runner services (old URL → new URL, domain URLs, branch, start/build commands, port, vCPU, memory and service configuration) used during migrations or as reference for deployment and ops. Content: single file app-migration.json – an array of migration objects. Each object describes one App Runner service. Services in the data include: carbify-dashboard-backend (prod and stage); carbondebits-portal-backend → carbify-portal-backend (prod and dev); stage-carbify-web3-api and carbify-latest-develop-stage (web3-api staging/prod); web3-api-development-latest (web3-api dev); crc-x-lambda-api (dev and prod), later carbify-certificates-backend; portal-api-development-latest (portal-backend dev). Purpose: single place for all App Runner service definitions and configuration for migration (e.g. old to new App Runner URLs or to domain URLs) and for ops/deploy reference. No application code, no scripts or package.json; JSON data only. Can be consumed by migration scripts, documentation or manual App Runner (or other environment) configuration. Tech: JSON only; no runtime or build tooling. Repo: single file, main branch.

Node.js/Express REST API for the Global Carbon Registry: manage carbon projects (properties), carbon debits, co-transactions and blockchain sync. Backend for carbify-registry-ui; data in MongoDB, optional read-from-chain via ethers (EVM). Auth: cookie-based JWT (login/signup); protected admin routes for CRUD on projects. Properties (posts): projects with name, proponent, developer, type, country, region, plotSize/systemSize, carbon-debit fields (per year, generated, spent, available), batch fields (batchNumber, initialSupply, plantTime, etc.), documents (imageUrl, check, version, sign, initial, final, other) via upload to /api/upload (Vercel Blob), optional on-chain data via contract address and GET /api/contracts/:id. Co-transactions: projectId, aCO2Id, treeId, carbonCertificateId, amount, date, txHash, geoLocation; filters, pagination, sorting; carbon summary per project; CSV export with date range. Purchase: register purchases (username, useremail, country, wallet, ip). Worker (cron): hourly via Vercel Cron (/api/worker) – recomputes carbonDebitsGenerated/Spent/Available for all projects; fetches spent credits via Carbon Certificate contract (tokenURI metadata, burned_tokens). Scripts: update-db.js (sync batch details from Nftree contracts to Post docs), update-projects.js (bulk update documents). Contract integration: ethers with NftreeABI, aCO2TokenABI, CarbonCertificateABI. Auth: JWT in httpOnly cookie; userVerification middleware. Files: multer + Vercel Blob (registry-files/); delete via Blob. Mail: SendGrid (e.g. exclusion notifications). Deploy: Vercel (api/index.js serverless, maxDuration 200s). Tech: Node.js, Express 4, Mongoose 8, MongoDB, cookie-parser, body-parser (5mb), cors (credentials), express-validator, bcrypt, jsonwebtoken, multer, @vercel/blob, ethers 6, dayjs, uuid, pdfkit, @sendgrid/mail. Routes (/api): post (add, change, duplicate, delete, get, getCount, getTotalCount, deletePostFile); auth (post/signup, post/login, post with userVerification); trans (get, add, summary, export); contracts/:id; purchase; upload; worker (GET cron).

Django/Python REST API backend for the Climate Cooperative dashboard: users, wallets, NFTs (plots, NFTrees), staking, ACO2, CBY tokens and marketplace. Data from PostgreSQL (users, marketplace listings/offers, token purchases) and from Ethereum chain and external providers (Moralis, RPC). Users (/api/users/): registration, JWT login (SimpleJWT), token refresh/verify, profile (get/update), delete, password reset (request, confirm, complete), TOTP 2FA (create, verify, delete). User model: email, username, country, bio, kyc_status, profile_picture, is_two_factor_enabled. Wallets (/api/wallets/): transactions per wallet (Moralis), CBY balance (Web3 + ABI). NFTs (/api/nfts/): collection per wallet (provider and Carbify NFT contract), NFT transfer history (Moralis). Plots (/api/plots/): per wallet genesis/rare/standard plots via provider (Genesis/Rare/Standard Plot contracts). Staking (/api/staking/): per wallet staked plots (standard/premium/genesis), NFTrees (owned vs staked per type), ACO2 rewards, required CBY to stake per tree (Web3 and staking/carbify services). Tokens (/api/tokens/): buy-tokens (POST, OTP-verified); store token-sale data, notify via SendGrid. ACO2 (/api/aco2s/<wallet>/): ACO2 balance (all-time rewards) via Web3. ACO2 pools (/api/aco2-pools/): list pools (pool_id, aco2_amount, pledged, price_per_aco2, expire_date, active, buyer) from chain. CBY (/api/cby/): live CBY price (CoinMarketCap), auth required. Marketplace (/api/marketplace/): listings (CRUD), listings-of-owner, NFT offers per listing; Listing and Offer models. NFTrees (/api/nftrees/): per wallet owned NFTrees with metadata (provider and token URI), pagination (page_key, page_size). Chain/config: contract addresses and ABIs (abis/) for ACO2, ACO2 pool, CBY, Carbify NFTs, marketplace, staking, NFTree batches 1–6, Genesis/Rare/Standard plots. Async: Celery (Redis broker), shared tasks in nfts, nftrees, marketplace. Tech: Django 4.1, Python 3.8, Django REST Framework, SimpleJWT, django-cors-headers, psycopg2, Pillow, requests, Moralis, Web3, SendGrid, django-otp, Celery, Redis, isort. Scripts: manage.py (runserver, migrate, etc.); dependencies via Pipfile/Pipfile.lock.

React frontend for the Climate Cooperative/Sproutly ecosystem: user dashboard with auth, wallet linking (Polygon), NFTrees and landplots, staking, marketplace, aCO2 pools and carbon footprint calculator. Data from an external REST API and on-chain via Wagmi/ethers. Auth: JWT (access/refresh) via /users/login/, register, forgot/reset password, optional 2FA (/two-factor-authentication); token refresh in axios interceptor (/users/token/refresh/), verify via checkAuth. Route guards: AuthenticatedRoutes (logged in, and 2FA if enabled), WalletAddressRoutes (requires connected wallet). Routes: public (/, /login, /register, /forgot-password, /reset-password, /carbon-footprint-calculator); after login (/connect-wallet); after login and wallet (/dashboard, /nfts, /nftrees/:asset_contract, /plots/:asset_contract, /staking, /marketplace, /aCO2-pools, /carbon-calculator, /profile, /listing/:listing_id). Unknown paths → UnderMaintenancePage. Dashboard: welcome text, CBY live price, cards (NFTrees owned, landplots Genesis/Rare/Standard), claim-aCO2 card, line chart; data from API and contracts. NFTs and landplots: NFTrees per asset_contract, landplots (Genesis/Rare/Standard) via API and contract reads. Staking: Genesis/Rare/Standard plots – stake/unstake/withdraw, buy plot, allow trees/CBY; rewards via API (staking/aco2-rewards/, stake/reward/, stake/claim) and contracts. Marketplace: listings list and detail, NFT offers; buy and bids on listing page. aCO2 pools: view and claim aCO2 rewards via API. Carbon calculator: steps (Get started, House, Air travel via Carbon Interface API, Transport, Secondary, Results); public (/carbon-footprint-calculator) and logged-in (/carbon-calculator). Profile: get/update (/users/profile/), delete account (/users/delete/). Blockchain: Polygon (and Mumbai), Wagmi (MetaMask, Coinbase, WalletConnect), Alchemy RPC; contract addresses and ABIs in BlockchainConstants (NFTree batches, Genesis/Rare/Standard plots, CBY, USDC, aCO2, marketplace, stake, airdrop, price proxy); reads/writes via ethers in readFromContract/ and writeOnContract/. Tech: React 18, JavaScript, CRA, React Router 6, Redux Toolkit, Tailwind CSS, Axios (JWT interceptor, dayjs for token expiry), Wagmi, ethers 5, Chart.js, dayjs, moment, jwt-decode, react-toastify, react-datepicker, react-helmet, react-icons, qrcode, http-proxy-middleware. Scripts: start, build, test, eject.

Solidity/Foundry repository for cross-chain bridging of the Climate Cooperative token (CBY) via Wormhole. Based on the Wormhole hello-wormhole example; extended with Climate Cooperative–specific contracts for lock/deposit on source chain and withdraw on destination chain. Contracts: CbyWormholeBridge – implements IWormholeReceiver; sendCrossChainDeposit(receiver, amount, extraGasLimit) locks CBY at Vault, approves and calls Wormhole Relayer sendPayloadToEvm to a configured counterparty (crossChainCounterParty, crossChainId); receiveWormholeMessages validates relayer and source chain/address, decodes payload and has Vault pay out to receiver; quoteCrossChainCall for costs; MIN/MAX gas limits; initialisable via initialize(vault, cby, crossChainCounterParty, crossChainId). Vault – holds CBY (ERC20); AccessControl (ACCESS_ROLE, DEFAULT_ADMIN_ROLE); setCBYToken (once), deposit/withdraw (ACCESS_ROLE only), withdrawETH, grantAccessRole/revokeAccessRole; bridge has ACCESS_ROLE for lock/unlock. CbyEth / CbyPoly – ERC20 implementations of Carbify (CBY) for Ethereum and Polygon (including flattened versions in src/flat/ for Etherscan/Polygonscan verification). Extensions – HelloWormholeRefunds, HelloWormholeProtections, HelloWormholeConfirmation as reference/examples for Wormhole Relayer (refunds, source-check, delivery confirmation). Deploy/ops: TypeScript scripts in ts-scripts/ (deploy per chain from config, getStatus for Wormhole Relayer delivery status via @certusone/wormhole-sdk); config and deployed addresses in ts-scripts. Tech: Solidity 0.8.13, Foundry (Forge), Wormhole Solidity SDK (IWormholeRelayer, IWormholeReceiver), OpenZeppelin (AccessControl, Ownable, Initializable, IERC20), ethers v5, TypeChain, ts-node, Jest. Libs (submodules/remappings): forge-std, wormhole-solidity-sdk, openzeppelin-contracts. Scripts: build (npm install, forge build, typechain), deploy, test (Jest), status (--getStatus with optional --txHash), main (ts-node main.ts), clean.

NestJS/TypeScript backend for the Climate Cooperative/Sproutly ecosystem: users, NFTrees (NFT trees), plots (land parcels), collections, listings and staking. Data in PostgreSQL via Prisma. Auth: JWT and refresh tokens; login via POST /auth/login (email/password, Passport Local), refresh via POST /auth/refresh; forgot and reset password via email (SendGrid, EJS templates). Users: registration, profile (JWT-protected), update profile, forgot/reset password. Collections: CRUD; type (NFTree/Plot), name, ABI, address, txHash. Trees (NFTrees): create, list all, trees per wallet (via Alchemy NFT API); link to Plot and Collection. Plots: create, list all, per wallet, per wallet and contract; PlotTypes (GENESIS, PREMIUM, STANDARD) with maximumSupply, activationPrice, unstakeSubtractRatio, maximumNFTreeCanBePlanted, aCO2BonusRatio, etc. Listings: CRUD for Plot and NFTree listings (price, link to plot/tree). Stake: stake NFTrees on plots via POST /stake; integration with Alchemy (NFT balances, contract owners); store staking transactions and StakedNFTrees (wallet, email, treeAddress, treeId, isStaked). App: health-check at /app/health-check. Swagger at /api when not in production. CORS, Helmet. Tech: NestJS 10, TypeScript, Prisma 5, PostgreSQL, Passport (JWT, Local), Alchemy SDK, SendGrid, EJS, crypto-js, class-validator/class-transformer, Swagger. Scripts: start, start:dev, start:debug, start:prod, build, test, test:e2e, test:cov, lint, format, migrate:prod (Prisma deploy). Docker: multi-stage (development, build, production), Node 18 Alpine.