Multi-Chain NFT

🔹 Multi-Chain NFT

1. TON NFT as Narrative Ticket

Within the Telegram Mini-App, users receive TON NFTs that serve as:

• Proof of participation in narrative creation

• Access key to content generation processes

• Unique identifier (UUID) for cross-chain synchronization

TON NFT metadata structure

json:

{
  "portal_comic": {
    "uuid": "COMIC_550e8400-e29b-41d4-a716-446655440000",
    "type": "generative_comic",
    "world_id": "PORTAL_ALPHA",
    "prompt_hash": "QmXYZ123...",
    "validator_signature": "0x789abc...",
    "status": "ton_minted"
  }
}

2. Stellar Custom Asset as Canonical Artifact

After TON NFT verification, users can convert it into a Stellar Custom Asset via a decentralized bridge:

Key characteristics of Stellar NFT Comics:

• CLAWBACK_ENABLED — Programmable recall for redrops or updates

• AUTHORIZATION_REQUIRED — Controlled distribution through trustlines

• Extended metadata in IPFS, including full narrative structure

Soroban smart contract for issuance

rust:

fn mint_comic_nft(
    recipient: Address,
    uuid: String,
    world_asset_code: String,
    metadata_ipfs_cid: String,
    unlock_conditions: Vec<Condition>
) -> Result<Asset, Error> {
    // Verify origin from TON NFT
    require(ton_bridge.verify_uuid(uuid), "Invalid TON NFT proof");
    
    // Create Stellar Asset with canonical metadata
    let asset = Asset::new(
        format!("COMIC_{}", uuid),
        PORTAL_ISSUER,
        CLAWBACK_FLAG | AUTH_REQUIRED_FLAG
    );
    
    asset.set_metadata(metadata_ipfs_cid);
    asset.set_issuer_flags(unlock_conditions);
    
    Ok(asset)
}

3. ERC-721 on Polygon as Tradable Asset

For monetization on Rarible, Stellar NFTs are mirrored to ERC-721 via an automated bridge:

Automatic listing process:

1. User confirms bridge via web interface
2. TON NFT → Stellar Asset conversion
3. Stellar Asset locked in Soroban escrow
4. ERC-721 minted on Polygon with same UUID
5. Automatic listing on Rarible with pre-configured royalties

---

🔹 Content Generation Technology Implementation

Hybrid creation approach:

1. Narrative framework: Unique plot tied to world_id

2. Image generation: Stable Diffusion XL with custom LoRAs

3. Artistic curation: Post-processing and composition

4. Interactive elements: Embedded triggers and hidden content

IPFS metadata structure

json:

{
  "comic_manifest": {
    "version": "2.0",
    "uuid": "COMIC_550e8400-e29b-41d4-a716-446655440000",
    
    "narrative": {
      "title": "Echo of Crystal Spheres",
      "world_id": "PORTAL_ALPHA",
      "canon_status": "primary",
      "chapters": 5,
      "interactive_elements": ["hidden_map", "character_dossier", "puzzle_lock"]
    },
    
    "generation": {
      "ai_model": "stable-diffusion-xl",
      "lora_model": "portal_fantasy_v2",
      "seed": 42424242,
      "style_preset": "digital_art"
    },
    
    "multichain": {
      "ton_nft": "EQABC123...",
      "stellar_asset": "PORTAL_COMIC_ABC123",
      "polygon_token_id": 12345,
      "rarible_url": "https://rarible.com/portal-comic/12345"
    },
    
    "unlock_conditions": [
      {
        "type": "stellar_stake",
        "asset": "$PORTAL",
        "amount": 5000,
        "contract": "GSTAKE123..."
      },
      {
        "type": "nft_ownership",
        "asset": "GRABBER_LEGENDARY",
        "required": true
      }
    ]
  }
}

---

🔹 Cross-Chain Functionality and Utility

Interaction through Telegram Mini-App:

• Reading comics: Streaming from IPFS via CDN

• Activating interactivity: Ownership verification through Horizon API

• Progress synchronization: Reading position saved in reputation attestations

Programmable content unlocking

rust:

// Soroban contract for access verification
fn check_comic_access(
    user: Address,
    comic_uuid: String,
    required_conditions: Vec<Condition>
) -> bool {
    // 1. Verify ownership of comic Stellar Asset
    let has_comic = user.has_asset(format!("COMIC_{}", comic_uuid));
    
    // 2. Check additional conditions
    for condition in required_conditions {
        match condition.type {
            "stellar_stake" => {
                require(user.staked_amount(condition.asset) >= condition.amount);
            }
            "nft_ownership" => {
                require(user.has_asset(condition.asset) == condition.required);
            }
            "reputation_level" => {
                let attestation = reputation_engine.get_attestation(user);
                require(attestation.level >= condition.min_level);
            }
        }
    }
    
    return has_comic && all_conditions_met;
}

---

🔹 NFT Comics Formats and Specifications

Format	TON NFT (Entry)	Stellar Asset (Core)	Polygon ERC-721 (Trading)
Flash Comic (1 page)	Minimal metadata, fast issuance	Basic Stellar Asset	Low-cost listing on Rarible
Short Story (3-5 pages)	UUID + prompt hash	Extended metadata, access conditions	Standard ERC-721 with premium attributes
Graphic Novel (20+ pages)	Multi-stage issuance	Composite Asset with chapters as sub-assets	Collectible ERC-721 with auction listing
Interactive Comic	Interactive elements in metadata	Smart Asset with embedded logic	ERC-721 with unlockable content on Rarible

---

🔹 Monetization and Royalty Mechanism

Three-tier distribution system:

1. Primary sale (TON → Stellar):

   • User pays TON for NFT in mini-app

   • 85% converted to XLM for creator

   • 15% remains in ecosystem for development

2. Secondary market (Polygon/Rarible)

solidity:

// Automatic royalties on Rarible
function getRoyaltyInfo(uint256 tokenId, uint256 salePrice) 
    external view returns (address receiver, uint256 royaltyAmount) 
{
    // 1. Identify original creator via UUID
    address creator = uuidToCreator[tokenIdToUUID[tokenId]];
    
    // 2. Calculate distribution
    uint256 creatorRoyalty = salePrice * 7 / 100;    // 7% to creator
    uint256 worldRoyalty = salePrice * 3 / 100;      // 3% to world owner
    uint256 ecosystemRoyalty = salePrice * 2 / 100;  // 2% to ecosystem
    
    // 3. Total 12% royalties
    royaltyAmount = creatorRoyalty + worldRoyalty + ecosystemRoyalty;
    
    // 4. Distribution via distributor contract
    receiver = PORTAL_ROYALTY_DISTRIBUTOR;
}

Cross-chain revenue conversion:

• Royalties in MATIC/ETH automatically converted to XLM

• Distribution via Soroban contract on Stellar

• Weekly payouts in native XLM

---

🔹 Integration with PORTAL POINT Ecosystem

Connection with game worlds:

• Narrative canonicity: Each comic verified in PORTAL CORE

• Game utility: Comic ownership provides HERO2QUEST bonuses

• Reputation bonuses: Collection enhances Proof-of-Participation Protocol level

Co-authorship mechanism

rust:

// DAO voting for narrative development
fn propose_canon_extension(
    comic_uuid: String,
    extension_content: String,
    proposed_by: Address
) -> ProposalId {
    // 1. Only comic owners can propose extensions
    require(holder_balance[proposed_by][comic_uuid] > 0);
    
    // 2. Create DAO proposal
    let proposal = ComicProposal {
        comic_uuid,
        extension_content,
        proposer: proposed_by,
        votes_for: 0,
        votes_against: 0,
        status: ProposalStatus::Active
    };
    
    // 3. Voting by $PORTAL holders
    proposals.push(proposal);
    
    return proposal.id;
}

---

🔹 Technology Stack

Component	TON Layer	Stellar Layer	Polygon Layer
Blockchain	TON (TEP-62)	Stellar (Soroban)	Polygon (ERC-721)
Storage	IPFS (metadata)	IPFS + Stellar Ledger	IPFS + Arweave
API	TON API	Stellar Horizon API	Rarible API, Alchemy
Wallets	TonConnect	Stellar SDK	MetaMask, WalletConnect
Bridge	TON → Stellar (validators)	Stellar → Polygon (official bridge)	—

🔹 Multi-Chain Narrative Artifacts in the PORTAL POINT Ecosystem

UNIQUE NFT COMICS are digital narrative artifacts implemented in the format of graphic novels unfolding within the worlds of PORTAL POINT. These are not merely works of art, but narrative portals captured in unique digital assets that exist simultaneously across three blockchains: TON, Stellar, and Polygon.

Each comic begins as a TON NFT (TEP-62) within the Telegram Mini-App, transforms into a Stellar Custom Asset for verification and utility, and is mirrored as an ERC-721 on Polygon for trading on Rarible marketplaces.