FOR BUILDERS

Develop on MT-ECO SYSTEM

Build applications, games, tools, bridges and extensions that integrate directly with the self-built MT network, INFINITE WALLET, native $MT token, Rockets economy, and on-chain NFTs.

Developer Landing — Core Principle

To successfully build the MT ECO SYSTEM and support cross-platform development (Web, iOS, Android, Windows) alongside your virtual gallery experience, you need to balance Core Blockchain Infrastructure with a seamless Developer Experience (DX) Layer.

Here is the breakdown of what you need to build and document.

1. THE CORE INFRASTRUCTURE

Backend & Nodes

Self-hosted Solana validator / custom MT L1 nodes
RPC endpoints, WebSocket feeds (live Rockets, NFT mints, bridge proofs, game states)
Indexers for holders, Rockets balances, NFTs, game progress, and cross-title achievements
Secure key management, program deployment pipelines, and audited upgrade authority flows
Direct on-chain execution (no third-party relayers for core value transfer)

2. IDENTITY BRIDGE

MT-Connect (Social + Wallet SSO)

Wallet-native identity (INFINITE WALLET pubkey is the primary key). Optional social login (OAuth) for Facebook, Instagram, TikTok, Snapchat, Google, Microsoft. These are used ONLY for username association, cross-device recovery hints, ecosystem perks and single-sign-on across games — never custody of keys.

Click any platform to start a real OAuth consent flow + simulated (but realistic) backend API exchange exactly like production MT-Connect would perform.

Facebook

Meta Graph API (public_profile, email)

📷

Instagram

Instagram Basic Display / Graph API

♪

TikTok

TikTok Login Kit (user.info.basic)

👻

Snapchat

Snap Kit Login + Bitmoji (if enabled)

Google

OpenID Connect (email, profile, openid)

Ⓜ

Microsoft

Microsoft Identity (openid, profile, email)

Real implementation: your backend receives the OAuth code, exchanges it server-side for tokens (never expose secrets to browser), calls the provider userinfo/Graph endpoint, then calls internal MT identity service to create or link the record. The returned MT-JWT is then used for all subsequent game and wallet API calls.

3. DEVELOPER DOCUMENTATION

Quick Start • API Reference • Guides

Quick Start

Install the MT SDK via npm: npm install @mt-ecosystem/sdk
Connect your INFINITE WALLET or any self-custodial Solana/MT wallet (see live demo below — deeplink + injected, same as the SolanaReels game).
Use MT-Connect for optional social SSO (the 6 platforms above).
Call SDK methods or raw program instructions for swap, bridge, harvest, mint, etc.

API Reference (selected)

GET /v1/wallet/:pubkey — balances + Rockets + linked socials
POST /v1/identity/connect — after OAuth (Facebook/IG/TikTok/Snapchat/Google/Microsoft)
POST /v1/transactions — submit signed tx (self-custodial)
GET /v1/games/:slug/progress — cross-game state
WS /ws — live Rockets, NFT events, bridge proofs

Integration Guides by Platform

• React / Next.js — useWallet + MTClient

• Unity / Unreal — native C# / C++ bindings + Solana RPC

• Swift (iOS) / Kotlin (Android) — direct RPC + MT-Connect deep links

• Flutter — single codebase with web3dart + custom channels

Error Handling & Limits

Standard JSON errors with code + message. Rate limits per IP + per wallet. Devnet has relaxed limits. All critical calls are idempotent where possible.

4. IMPLEMENTATION PRIORITY MAP

CRITICAL

Core node + RPC + basic SDK
SIWS (Sign-In with Solana) + MT-JWT auth
Basic swap / bridge / harvest endpoints
MT-Connect core (at least Google + wallet)

HIGH

Full MT-Connect (all 6 platforms + deeplink support)
Game SDK hooks (Rockets, NFTs, progress sync)
Live WebSocket feeds
Analytics & leaderboards

MEDIUM

NFT mint templates + studio UI
Advanced routing / gasless options
Unity/Unreal/Flutter example repos
Public testnet faucet + explorer

RECOMMENDED NEXT STEPS

1. Stand up the self-hosted RPC + indexer layer. 2. Implement MT-Connect backend (OAuth exchange + identity linking service). 3. Publish the first version of the @mt-ecosystem/sdk with wallet + MT-Connect helpers. 4. Build the live sandbox (this page) into a full interactive API explorer with real devnet calls. 5. Document every program instruction (like Raydium/Jupiter docs style — already partially included below).

SDK REFERENCE

Core Classes & Methods

MTClient

Main entry point for all on-chain interactions.

constructor(options: { wallet, rpcUrl? })
getBalance(mint: 'MT' | 'SPL' | string): Promise<number>
bridge(params): Promise<TxSignature> — Native ↔ SPL
swap(params): Promise<TxSignature> — Jupiter routed or direct
harvestRockets(game: string): Promise<TxSignature>

WalletAdapter

Self-custodial wallet helpers (Phantom, Solflare, Backpack, INFINITE WALLET).

connect(): Promise<PublicKey>
signTransaction(tx: Transaction): Promise<Transaction>
deriveSubWallet(role: 'couple' | 'team' | 'auditor'): Keypair

FlowBuilder

For ONE-PLACE MANAGEMENT FLOWS (NFT designer, staking preview, reports, constellation).

buildBridgeFlow(direction, amount)
buildReport(): MerkleProof
simulateNFTMint(traits): PreviewNFT

API ENDPOINTS

REST & On-Chain APIs

GET /api/holders

Live holder & stats data (used by TokenStats).

Returns Dexscreener-style payload + on-chain holder count.

On-chain: Bridge / Swap / Harvest

Direct program calls via INFINITE WALLET or SDK. No third-party relayers.

WebSocket: Live Flows

Subscribe to real-time Rockets earnings, NFT mints, bridge proofs.

wss://api.mt-ecosystem.futuret3ch.com/ws

EXAMPLES

Quick Integrations

React + Wallet

import { useWallet } from '@solana/wallet-adapter-react';
import { MTClient } from '@mt-ecosystem/sdk';

function MyDapp() {
  const { wallet } = useWallet();
  const client = new MTClient({ wallet });

  const handleBridge = async () => {
    const sig = await client.bridge({ 
      direction: 'native-to-spl', 
      amount: 5_000_000 
    });
    console.log('Bridged:', sig);
  };

  return <button onClick={handleBridge}>Bridge 5M MT</button>;
}

Node / Backend (with license)

import { MTClient } from '@mt-ecosystem/sdk';
const client = new MTClient({ 
  rpcUrl: process.env.MT_RPC, 
  licenseKey: process.env.MT_LICENSE 
});

const report = await client.generateAuditReport({ 
  wallet: 'YourBusinessVaultPubkey',
  includeNFTs: true 
});

Wallet Connection (Injected + Mobile Deeplink)

Manual provider detection for Phantom, Solflare and Backpack. Works on desktop via injected providers. On mobile it falls back to universal/deeplinks so the user can open the page inside the wallet browser and connect directly.

On mobile without an injected provider the buttons open a deeplink. Open the site from inside Phantom, Solflare or Backpack and the injected path will be available.

RESOURCES & DOWNLOADS

SDKs, Tools & Docs

Downloads (SDKs, mobile libs, browser extensions) are currently disabled / coming soon. Check back or contact for access.

All packages are open for licensed developers. Full source and more examples in the MT GitHub org (coming soon). Email Support@MemeTorrent.com for early access keys.

Sandbox (Devnet + MT-Connect)

Test endpoints safely. Social OAuth flows above already exercise the real identity API pattern. These are additional mocks.

Real Devnet + production MT-Connect endpoints coming soon. Contact for current program specs.

GET STARTED

Docs

AI

Our AI assistant (powered by on-site Grok-like responses) helps with questions about $MT, wallet, utilities, and more. See the contact page for the live chat.

Tool Kits

SDKs and toolkits for integrating with MT-ECO SYSTEM. (Downloads currently disabled.)

Changelog

Track updates to the SDK, APIs, and on-chain features. Full changelog coming soon in the MT GitHub.

Get Started

AI • Tool Kits • Changelog • Resources

Swap

Overview: One API for all swap use cases on MT-ECO SYSTEM (inspired by Meta-Aggregator patterns).

Meta-Aggregator: All routers compete for the best price. You get a fully assembled transaction, sign it, and MT handles landing. Best for most integrations.

Router: Metis onchain routing. Get raw swap instructions to build your own transaction. Add custom instructions, CPI, or modify the transaction however you need.

Choosing a path: Start with Meta-Aggregator for best price. Only use the Router if you need to modify the transaction.

Order & Execute

The Swap API unifies capabilities into a single entry point. Two paths cover every use case: Meta-Aggregator (all routing engines compete for the best price. You get a fully assembled transaction, sign it, and Jupiter handles landing) and Router (Metis onchain routing only. You get raw swap instructions with full transaction control for custom builds, CPI, and composability).

Router

Build: Common Instructions, Transaction Submission (GET /build, POST /submit). Self-managed via your own RPC, or via /submit with SOL tips for Jupiter’s proprietary landing pipeline.

Advanced

Overview, Slippage Estimation, Gasless Swaps, Compute Units & Priority Fees, Reduce Transaction Size, Reduce Latency, Routing Integration, Integrate DEX into Metis, Market Listing, Integrate MM into JupiterZ (RFQ).

Guides

Embed Swap Widget, Migration (Metis to Router, Metis to Meta-Aggregator, Ultra to Meta-Aggregator).

Resources

Token info and integration guides. See links above and the main site sections for LIVE $MT, flows, and TAP.

Swap

Overview: One API for all swap use cases on MT-ECO SYSTEM (inspired by Meta-Aggregator patterns).

Meta-Aggregator

All routers compete for best price. Get a fully assembled transaction, sign it, and MT handles landing. Best for most integrations.

Router

On-chain routing only. Get raw swap instructions with full transaction control for custom builds, CPI, and composability.

Choosing a path: Start with Meta-Aggregator for best price and simplicity. Use Router only if you need to modify the transaction.

Endpoints (example structure)

GET /swap/order — Get a quote and assembled transaction
POST /swap/execute — Execute a signed transaction with managed landing
GET /swap/build — Get a quote and raw swap instructions
POST /tx/submit — Submit signed transaction

Advanced

Gasless swaps, compute unit estimation, reducing transaction size and latency, slippage estimation, priority fees.

Guides

Embed Swap Widget, Migration guides (e.g. from older flows to new router/meta-aggregator), Integrate DEX into MT routing, Market Listing.

Order & Execute

The Swap API unifies Jupiter’s swap capabilities into a single entry point at https://api.jup.ag/swap/v2. Two paths cover every use case: Meta-Aggregator (all routing engines compete for the best price. You get a fully assembled transaction, sign it, and Jupiter handles landing) and Router (Metis onchain routing only. You get raw swap instructions with full transaction control for custom builds, CPI, and composability).

Router

Build: Common Instructions, Transaction Submission (GET /build, POST /submit). Self-managed via your own RPC or /submit with SOL tips.

Advanced

Guides

Embed Swap Widget, Migration (Metis to Router, Metis to Meta-Aggregator, Ultra to Meta-Aggregator).

Core architecture, token mechanics and integration concepts are available via the main site and contact.

← Back to MT ECO SYSTEM