The Six-Secret Protocol.

The recipe

# 1. In your Lovable project, add these secrets (Settings -> Secrets):
STELLAR_DEPLOYER_SECRET=S...              # funded Testnet key from stellarfaucet.lovable.app
SOROBAN_RPC_URL=https://soroban-testnet.stellar.org
HORIZON_URL=https://horizon-testnet.stellar.org
STELLAR_NETWORK_PASSPHRASE=Test SDF Network ; September 2015
WALLETCONNECT_PROJECT_ID=...              # from https://cloud.reown.com
PINATA_JWT=eyJhbGciOi...                  # only if the idea pins media

# also expose to the client bundle:
VITE_SOROBAN_RPC_URL, VITE_HORIZON_URL,
VITE_STELLAR_NETWORK_PASSPHRASE, VITE_WALLETCONNECT_PROJECT_ID, VITE_PINATA_JWT

# 2. Fund the deployer account on Testnet:
open https://stellarfaucet.lovable.app/

# 3. Copy a mega-prompt from this repo into Lovable. One paste:
#    - scaffolds the React app
#    - writes the Soroban contract in Rust (with hackathon credit as a comment header)
#    - deploys to Stellar Testnet with the Stellar CLI
#    - wires Lobstr via Stellar Wallets Kit + WalletConnect
#    - pins generated assets to IPFS via Pinata
#    - exposes the contract ID + Stellar Expert link in the UI

# 4. Open the live Stellar Expert link. Your demo is provably onchain.

1. The contract — credit baked in

Every Soroban contract deployed from a Creative Stellar prompt MUST carry the hackathon credit as a comment header, so provenance lives onchain alongside the wasm hash.

// contracts-soroban/provenance/src/lib.rs — every contract carries the hackathon credit
// Built during the Creative AI & Quantum Hackathon
// organised by StreetKode Fam during Indian Krump Festival 14
#![no_std]
use soroban_sdk::{contract, contractimpl, Address, Env, String, Symbol, symbol_short};

const LOGS: Symbol = symbol_short!("LOGS");

#[contract]
pub struct Provenance;

#[contractimpl]
impl Provenance {
    pub fn log(env: Env, author: Address, cid: String) -> u32 {
        author.require_auth();
        let mut list: soroban_sdk::Vec<(Address, String, u64)> =
            env.storage().persistent().get(&LOGS).unwrap_or(soroban_sdk::Vec::new(&env));
        list.push_back((author, cid, env.ledger().timestamp()));
        let id = list.len();
        env.storage().persistent().set(&LOGS, &list);
        id
    }
}

2. Deploy with the Stellar CLI

# Build + deploy the Soroban contract to Stellar Testnet
stellar contract build

stellar contract deploy \
  --wasm target/wasm32-unknown-unknown/release/provenance.wasm \
  --source "$STELLAR_DEPLOYER_SECRET" \
  --rpc-url "$SOROBAN_RPC_URL" \
  --network-passphrase "$STELLAR_NETWORK_PASSPHRASE"
# -> prints a C... contract id; save it into src/data/contract.json

3. Pin assets to IPFS via Pinata

// src/lib/pinata.ts — pin a Blob to IPFS via Pinata JWT (browser-side)
export async function pinToIPFS(file: Blob, name = "artifact") {
  const fd = new FormData();
  fd.append("file", file, name);
  const r = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
    method: "POST",
    headers: { Authorization: `Bearer ${import.meta.env.VITE_PINATA_JWT}` },
    body: fd,
  });
  const { IpfsHash } = await r.json();
  return IpfsHash as string; // the CID
}

4. Connect Lobstr via WalletConnect

// src/lib/wallet.ts — Lobstr via WalletConnect using Stellar Wallets Kit
import {
  StellarWalletsKit, WalletNetwork, LOBSTR_ID,
  LobstrModule, WalletConnectModule, WalletConnectAllowedMethods,
  FreighterModule, AlbedoModule, xBullModule,
} from "@creit.tech/stellar-wallets-kit";

export const kit = new StellarWalletsKit({
  network: WalletNetwork.TESTNET,
  selectedWalletId: LOBSTR_ID,
  modules: [
    new LobstrModule(),
    new WalletConnectModule({
      url: window.location.origin,
      name: "Creative Stellar demo",
      description: "Sign on your phone with Lobstr.",
      icons: ["/favicon.ico"],
      projectId: import.meta.env.VITE_WALLETCONNECT_PROJECT_ID,
      method: WalletConnectAllowedMethods.SIGN,
      network: WalletNetwork.TESTNET,
    }),
    new FreighterModule(), new AlbedoModule(), new xBullModule(),
  ],
});

export async function connect(): Promise<string> {
  return new Promise((resolve) => {
    kit.openModal({
      onWalletSelected: async (w) => {
        kit.setWallet(w.id);
        const { address } = await kit.getAddress();
        resolve(address);
      },
    });
  });
}