# Starknet Re{solve}: Project Ideas & Technical Briefs

This document outlines a series of technical challenges and project ideas proposed by the Starknet Foundation and its partners.

These are starting points. Use them for inspiration. Improve upon them.

### **Key Links**

* **Hackathon Info, Prizes & Registration:** `https://resolve-starknet.devpost.com/`
* **Workshop Calendar:** `https://tinyurl.com/Resolveworkshops`
* **Community & Mentorship Group:** `https://t.me/+jpKehQcTM_o4MjFh`

### **How to Use This Document**

1. **Register** for the hackathon on Devpost to be eligible for prizes.
2. **Attend** the technical workshops to learn the tools.
3. **Ask** questions directly to sponsors and mentors in the Telegram support channel.

---
---

### **1) Idea: Abstracted Bitcoin dApp (From the Atomiq Team)**

Tracks: Bitcoin Unleashed and Mobile-First dApps. Problem: Starknet dApps require Starknet wallets and STRK/ETH for gas; Bitcoin users won’t do that. Proposal: wrap a top Starknet dApp (Vesu, Troves, Nostra) behind a Bitcoin-first interface. Users sign in with passkeys or social login and fund actions in BTC. No seed phrases. Gas is paid invisibly via a reserved USDC balance.

#### Key Technologies & Sponsors
Use Atomiq for cross-chain swaps and Starknet account abstraction for sign-in and recovery. Target protocols include Vesu and Troves.

#### Technical Architecture & Implementation
Account creation: a social-login gateway using Starknet.js, ArgentX/Braavos smart accounts, and WebAuthn. Users authenticate with passkeys or OAuth; you deploy the AA account and configure recovery behind the scenes.

# Create an AA account from a social login (pseudocode)
credential = authenticate(preferred_auth)        # passkey or social
account = deploy_account(owner=credential.pubkey, guardians=[credential])
setup_recovery(account, [credential, email_backup, phone_backup])

Gas abstraction: invisible fees in USDC via an AVNU paymaster and a simple BTC→USDC reservation.

# Reserve a small portion of bridged BTC for gas in USDC (pseudocode)
reserve_usdc = convert_wbtc_to_usdc(user_wbtc * 0.02)
paymaster = setup_paymaster(token="USDC")
execute(op):
  deduct_usdc(user, estimate_gas_usdc(op.gas))
  return paymaster.execute(op)

Cross-chain value transfer: simplified Atomiq SDK with built-in Lightning (no LND). Docs: https://www.npmjs.com/package/@atomiqlabs/sdk

# Atomiq handles Lightning directly (pseudocode)
atomiq = init_atomiq(network="mainnet")

to_starknet(btc_amount, target_token, speed):
  if speed == "instant":
    return atomiq.lightning_to_starknet(btc_amount, target_token)
  else:
    return atomiq.bitcoin_to_starknet(btc_amount, target_token)

from_starknet(starknet_asset, withdrawal_type):
  if withdrawal_type == "lightning":
    return atomiq.starknet_to_lightning(starknet_asset)
  else:
    return atomiq.starknet_to_bitcoin(starknet_asset)

Strategy engine: protocol integration Protocol ABIs/SDKs, a thin Cairo proxy

# Deposit flow (pseudocode)
deposit(btc_amount, strategy, user_preference):
  reserve_usdc = to_starknet(btc_amount * 0.02, "USDC", "instant")
  wbtc_amount = to_starknet(btc_amount * 0.98, "WBTC", user_preference)

  if strategy.type == "lending":
    return proxy.deposit_to_vesu(wbtc_amount)
  else:
    return proxy.deposit_to_troves(wbtc_amount)

Mobile experience: a Bitcoin-native UI in React Native with @starknet-react/core. Show BTC balance and APY; actions: Deposit, Withdraw, Change Strategy; hide Starknet details.

Smart contract orchestration: Cairo with Scarb and Foundry. A minimal proxy routes swaps and deposits and tracks positions.

# Minimal orchestration contract (pseudocode)
contract BitcoinDAppProxy:
  storage:
    atomiq_router_address
    vesu_pool_address
    troves_vault_address

  deposit_btc_and_earn(btc_amount, strategy):
    wbtc_amount = atomiq_router.swap_btc_to_wbtc(btc_amount)
    if strategy == 1:
      vesu_pool.deposit(wbtc_amount, caller_address)
    else:
      troves_vault.deposit(wbtc_amount, caller_address)
    return

#### Potential Outcome
A Bitcoin-native app (Deposit & Earn) powered by Starknet. Users fund in BTC; the system reserves USDC for gas and handles AA, paymastering, swaps, and protocol calls behind the scenes.

#### Key Differentiators
Bitcoin-only UX with zero Starknet cognitive load; Lightning support via simple SDK calls (no infrastructure); invisible gas paid in USDC and shown as BTC equivalents; mobile-first with passkey/social recovery; instant small payments, secure large deposits—one interface.

---

### **2) Idea: Starknet Lightning Privacy Mixer (From Starknet Foundation)**

Tracks: Privacy & Identity and Bitcoin Unleashed. Problem: on‑chain privacy on Starknet is immature; CEX “mixing” is slow and trust‑based. Proposal: use Lightning to break the on‑chain link: STRK (Account A) → Lightning BTC → STRK (Account B).

#### Key Technologies & Sponsors
Uses Atomiq for swaps, Lightning and Cashu for privacy, and Cairo for contracts.

#### Technical Guide
Use the Atomiq SDK to swap a Starknet asset (for example STRK on Account A) to BTC on a Lightning invoice, route the BTC through a Cashu e‑cash wallet to break linkability, then swap back into a Starknet asset on a different account (Account B). For stronger privacy, add time delays or split outputs across multiple destination wallets.

#### Potential Outcome
An easy-to-use privacy tool for Starknet users that is significantly faster than using a CEX for mixing and offers stronger privacy guarantees through technologies like Cashu.

---

### **3) Idea: Delta-Neutral BTC Vault (From StarkWare)**

Tracks: Bitcoin Unleashed and Open Innovation. Problem: most DeFi strategies carry price risk users don’t want. Proposal: a BTC vault that earns funding while hedging price with a spot‑versus‑perp delta‑neutral structure on Starknet.

#### Key Technologies & Sponsors
Uses a Starknet perpetuals DEX (eg, Extended) and, optionally, Vesu or Troves for collateral management.

#### Technical Guide
1. **Core Logic (Cairo Contracts):** The vault contract will accept WBTC deposits. It will then use this WBTC as collateral on a perps DEX to open a 1x long position. Simultaneously, it will open a 1x short BTC perp position of the same size.
2. **Hedging:** The combined long spot + short perp position creates a "delta-neutral" exposure, meaning the position's value is not significantly affected by the price of BTC going up or down. The primary source of yield will be the funding rate payments from the perpetuals market.
3. **Automation:** The core challenge is building the auto-rebalancing logic within the Cairo contract to manage the positions and harvest yield.
4. **Tokenization:** A key feature would be to issue a tokenized, yield-bearing receipt (e.g., `dnBTC`) to depositors, representing their share in the vault.

#### Potential Outcome
A sophisticated, delta-neutral yield product for BTC holders on Starknet, creating a source of native yield that is uncorrelated with market direction and attracting more BTC liquidity to the ecosystem.

---

### **4) Idea: One-Click Bitcoin Yield Shuttle**

Track: Bitcoin Unleashed. Problem: most BTC sits idle; moving it to DeFi is a multi‑step, high‑friction process. Proposal: a “one‑click” app that accepts native BTC (L1 or Lightning), bridges to Starknet, and deploys into a yield protocol automatically.

#### Key Sponsors
Starkware, Starknet Foundation, Xverse, Atomiq, Troves and Endur, Vesu.

#### Technical Guide:

1. **User Interface & Wallet:**
* **Tool:** **Xverse Wallet**. Build the front-end to connect seamlessly with the leading Bitcoin wallet.
* **Docs:** [Xverse Integration Guide](https://docs.xverse.app/)
2. **The Value Bridge (Cross-Chain Swaps):**
* **Tool:** **Atomiq SDK**. Use their SDK to handle the complex swap from a user's native BTC into a Starknet-compatible asset like WBTC.
* **Docs:** [Atomiq Website](https://www.npmjs.com/package/@atomiqlabs/sdk)
3. **The Yield Engine (Starknet Smart Contracts):**
* Your Cairo contract will receive the WBTC and automatically deposit it into a yield protocol.
* **Option A (Aggregator):** Use **Troves and Endur** to deposit into a yield vault.
* **Option B (Lending):** Use **Vesu** to supply the WBTC as collateral to earn lending interest.
* **Docs:** [Troves Website](https://www.troves.fi/), [Vesu Protocol Docs](https://docs.vesu.xyz/)
* **Language:** Your contracts must be written in **Cairo**. Start with the [Cairo Book](https://book.cairo-lang.org/).

#### Potential Outcome

Builds one of the most seamless BTC-to-DeFi-yield applications in crypto. A strong candidate for a Starknet Foundation grant to continue development.

-----

### **5) Idea: Invisible Crypto Payments**

Track: Next‑Gen Payments. Problem: self‑custody payments still feel worse than Venmo; addresses, gas, and seed phrases block adoption. Proposal: a mobile‑first payments app where users sign up with email, send to a username, and never see blockchain internals while retaining self‑custody on Starknet.

#### Key Sponsors
Starknet Foundation, Chipi Pay, Starkware Mobile-First dApps.

#### Technical Guide:

1. **The "Invisible Wallet" Backend:**
* **Tool:** **Chipi Pay SDK**. Use their SDK to create "invisible wallets" for your users, handling account creation and transaction signing behind the scenes.
* **Docs:** [Chipi Pay Website](https://www.chipipay.com/)
2. **The Seamless User Experience (Account Abstraction):**
* **Tool:** **Starknet's native Account Abstraction (AA)**. Use AA to enable Web2 features like social login/recovery and paymasters (sponsoring gas fees).
* **Docs:** [Starknet Account Abstraction Docs](https://docs.starknet.io/documentation/architecture_and_concepts/Accounts/introduction/)
3. **The Frontend:**
* Build a clean, mobile-first web app that mimics the user flow of Venmo.
* **Tools:** Use [Starknet.js](https://www.starknetjs.com/) to connect your frontend to your Starknet contracts.

#### Potential Outcome

Builds a crypto payments app that non-crypto users can actually use. A strong candidate for the Mobile-First dApp prize and a go-to wallet for a new wave of users.

-----

### **6) Idea: Cross-Chain Bitcoin Yield Vault with Instant Payments (Advanced)**

Tracks: Bitcoin Unleashed and Next‑Gen Payments. Problem: users want yield and instant spendability at once. Proposal: combine Starknet yield with Lightning payments to create a liquid Bitcoin savings account.

#### Key Sponsors
Starkware, Xverse, Atomiq, Chipi Pay.

#### Technical Guide:

1. **Backend:** Cairo smart contracts for yield vault management.
2. **Bitcoin Integration:** Use **Atomiq SDK** for direct Lightning payments—no separate infrastructure needed. The SDK handles instant payment channels internally, simplifying the integration significantly.
3. **Cross-Chain:** **Atomiq SDK** for seamless Bitcoin↔Starknet swaps with built-in Lightning support.
4. **Frontend:** Mobile app (e.g., React Native) with **Xverse** wallet connector and **Chipi Pay SDK** for invisible wallet creation.
5. **Yield Sources:** **Troves** yield aggregation strategies and **Vesu** lending protocols.

#### Potential Outcome

Delivers a sophisticated DeFi product that solves a major problem for the largest crypto asset. The simplified architecture using Atomiq's built-in Lightning capabilities makes this more achievable than traditional approaches. Startup-level idea with strong follow-on potential.

-----

### **7) Idea: Private Micropayments for Digital Content (Advanced)**

Tracks: Privacy & Identity and Next‑Gen Payments. Problem: creators face high fees and poor UX for small payments. Proposal: private Lightning micropayments with Starknet ZK proofs for access control.

#### Key Sponsors
Starkware, Fat Solutions, Wootzapp, Starknet Foundation.

#### Technical Guide:

1. **Privacy Layer:** Use **Starknet's native zk-STARKs** in your Cairo contracts to create a "shielded pool" for anonymous payment verification.
2. **Payments:** Integrate **Atomiq SDK** for instant, sub-cent Bitcoin micropayments via Lightning (no separate LND setup required).
3. **Identity & Added Value:** Use **Fat Solutions'** privacy protocols for ZK identity. Integrate **Wootzapp's** DePIN model to allow users to earn passive income while consuming content.
4. **Backend:** Node.js with Cairo smart contracts to manage the private settlement logic, using **Atomiq SDK** for Lightning operations.

#### Potential Outcome:

A powerful infrastructure piece for the creator economy, applicable to pay-per-article news, video streaming, in-game purchases, and pay-per-call APIs. Demonstrates the unique combination of Bitcoin liquidity and Starknet privacy with simplified Lightning integration.

---

### **8) Idea: Universal On-Chain Gaming Hub (Advanced)**

Tracks: On‑Chain Worlds & Gaming and Bitcoin Unleashed. Problem: assets and achievements are siloed per game, with no unified marketplace or cross‑game identity. Proposal: aggregate on‑chain data from Dojo‑powered games and provide a unified marketplace that uses Bitcoin as a primary currency.

#### Key Technologies & Sponsors
Uses Dojo for game frameworks, Cartridge for identity, and Xverse/Atomiq for Bitcoin payments.

#### Technical Implementation Guide:
1. **Aggregation Engine:** Build a system that can read, interpret, and normalize achievement and asset data from different Dojo games. This will likely require custom adapters for each game.
2. **Player Identity:** Use the Cartridge Controller to allow users to connect their identities from multiple games.
3. **Bitcoin Marketplace:** Build the marketplace logic in Cairo. Use the Xverse wallet for user connectivity and the Atomiq SDK for swaps between a buyer's BTC and the seller's desired Starknet asset.

#### Potential Outcome:
A platform that aggregates on-chain data from multiple Dojo-based games and provides a unified marketplace, potentially becoming a central hub for the Starknet gaming ecosystem.

-----

### **9) Idea: Native Bitcoin Collateral Perps Trading (by the Xverse team)**

**Track:** Bitcoin Unleashed. **Problem:** Bitcoin holders want to trade perpetuals without selling their BTC or moving to centralized exchanges that require KYC. Current perps DEXs require bridging and converting BTC to other assets, adding friction and counterparty risk. **Proposal:** Build a native Bitcoin perps trading interface that connects directly to Extended via Xverse wallet, allowing users to use their Bitcoin (BTC, Lightning BTC) as direct collateral without bridging, KYC, or centralized exchange accounts.

#### Key Technologies & Sponsors
Uses Extended protocol for perpetuals trading, Xverse wallet for Bitcoin authentication, and Starknet's native account abstraction for gasless trading execution.

#### Technical Architecture & Implementation

**Wallet Integration:** Direct Xverse wallet connection using their native Starknet integration (live since July 2025).

// Connect Xverse wallet with native Starknet support
import { connect } from "@starknet-io/get-starknet"

const connectXverseWallet = async () => {
  const starknet = await connect({
    modalMode: "alwaysAsk",
    modalTheme: "dark",
    include: ["xverse"]
  })
  
  if (starknet?.isConnected) {
    return starknet.account
  }
}

**Bitcoin Collateral Management:** Use Xverse's Bitcoin holdings as collateral through Asset Runes and Bitcoin staking integration (launching Q4 2025).

// Bitcoin Collateral Management Contract (Pseudocode)
Contract BitcoinCollateralPerps:
  
  Storage:
    btc_collateral_balances: mapping(user_address -> btc_amount)
    position_sizes: mapping(user_address -> position_data)
    extended_router_address: contract_address
  
  Function deposit_btc_collateral(amount, user):
    verify_bitcoin_signature(user.bitcoin_address, amount)
    current_collateral = btc_collateral_balances[user]
    btc_collateral_balances[user] = current_collateral + amount
    emit CollateralDeposited(user, amount)
  
  Function open_perp_position(market_id, size, is_long, user):
    collateral = btc_collateral_balances[user]
    require(collateral >= calculate_margin_requirement(size))
    
    // Route to Extended protocol
    call extended_router.open_position(user, market_id, size, is_long, collateral)
    
    // Update user position tracking
    position_sizes[user] = update_position(position_sizes[user], size, is_long)
    
  Function liquidate_position(user):
    position = position_sizes[user]
    current_price = get_oracle_price(position.market_id)
    
    if position_underwater(position, current_price):
      close_position_via_extended(user, position)
      deduct_liquidation_fee(user)

**Gasless Trading with AVNU Paymaster:** Use AVNU's paymaster service for invisible fees paid in BTC-equivalent tokens.

// AVNU Paymaster setup for gasless trading
import { Account, PaymasterRpc } from "starknet"

const setupAVNUPaymaster = async (xverseAccount) => {
  // Create AVNU paymaster instance
  const paymasterRpc = new PaymasterRpc({
    nodeUrl: 'https://starknet.paymaster.avnu.fi', // Mainnet
    // nodeUrl: 'https://sepolia.paymaster.avnu.fi', // Testnet
    headers: { 'api-key': process.env.AVNU_API_KEY } // Contact AVNU team for API key
  })
  
  // Create account with AVNU paymaster
  const account = new Account(
    provider,
    xverseAccount.address,
    xverseAccount.signer,
    undefined,
    undefined,
    paymasterRpc
  )
  
  // Configure fee payment in BTC-equivalent (USDC/USDT)
  const feesDetails = {
    feeMode: { 
      mode: 'default', // User pays with alternative token
      gasToken: '0x53b40a647cedfca6ca84f542a0fe36736031905a9639a7f19a3c1e66bfd5080' // USDC
    }
  }
  
  return { account, feesDetails }
}

// Execute gasless transaction
const executeGaslessTrading = async (calls, account, feesDetails) => {
  // Estimate fees in chosen token
  const feeEstimation = await account.estimatePaymasterTransactionFee(calls, feesDetails)
  
  // Execute with paymaster (user pays in USDC instead of STRK/ETH)
  const result = await account.executePaymasterTransaction(
    calls,
    feesDetails,
    feeEstimation.suggested_max_fee_in_gas_token
  )
  
  return result
}

**AVNU Paymaster Features (September 2025):**
- **Supported Tokens**: USDC, USDT, DOG (Bitcoin Runes), ETH, STRK, with more tokens added regularly
- **Integration**: Full SNIP-29 compatibility with starknet.js v7.6.4+
- **Documentation**: Available at [starknetjs.com/docs/guides/paymaster](https://starknetjs.com/docs/guides/paymaster/) and [docs.out-of-gas.xyz](https://docs.out-of-gas.xyz)
- **API Access**: Contact AVNU team via [Telegram developers channel](https://t.me/avnu_developers)
- **Open Source**: Full infrastructure available at [github.com/avnu-labs/paymaster](https://github.com/avnu-labs/paymaster)

**Extended Protocol Integration:** Direct integration with Extended's 50+ perps markets using their unified margin system (live on Starknet since August 2025).

// Extended API integration for perps trading
const ExtendedAPI = {
  async getMarkets() {
    return fetch('https://api.extended.exchange/v1/markets')
  },
  
  async openPosition(marketId, size, collateralType, account, feesDetails) {
    const contract = new Contract(ExtendedABI, ExtendedAddress, account)
    
    return contract.open_position(marketId, size, collateralType, {
      paymaster: feesDetails // Gasless via AVNU paymaster
    })
  },
  
  async getPositions(userAddress) {
    return contract.get_user_positions(userAddress)
  }
}

#### Potential Outcome
A Bitcoin-native perpetuals trading platform that allows users to trade derivatives using their Bitcoin as collateral without leaving the Bitcoin ecosystem or dealing with centralized exchange requirements. Users maintain self-custody while accessing sophisticated trading features.

#### Key Differentiators
No KYC or CEX accounts required; Native Bitcoin collateral without bridging conversion; Gasless execution with fees paid in BTC-equivalent tokens via AVNU; Access to 50+ markets including TradFi assets; Self-custody throughout the trading process; Lightning-fast execution on Starknet with 6-second block times.

---

### **10) Idea: Fractionalized Bitcoin Ordinals DeFi Platform (by the Xverse team)**

**Track:** Bitcoin Unleashed and Open Innovation. **Problem:** Valuable Bitcoin Ordinals (digital art, historical inscriptions) are becoming increasingly expensive, pricing out smaller investors. There's no way to get fractional exposure to blue-chip Ordinals or use them as collateral in DeFi. **Proposal:** Create a platform where users can vault their Ordinals on Bitcoin L1, issue tokenized shares on Starknet, and enable fractional trading, lending, and borrowing against Ordinal shares.

#### Key Technologies & Sponsors
Uses Xverse wallet for Ordinals management, Starknet Asset Runes for tokenization, Vesu protocol for lending/borrowing, and Ekubo for fractional trading.

#### Technical Architecture & Implementation

**Ordinals Vaulting System:** Secure Bitcoin L1 vault using multi-sig federation (similar to Asset Runes bridge infrastructure).

// Ordinals vault interface via Xverse
const OrdinalsVault = {
  async vaultOrdinal(inscriptionId, userBitcoinAddress) {
    // Generate unique vault address
    const vaultAddress = generateMultisigVault(inscriptionId)
    
    // User sends Ordinal to vault address via Xverse
    const xverse = await window.BitcoinProvider.request({
      method: 'sendBitcoin',
      params: {
        recipients: [{
          address: vaultAddress,
          amount: 546, // Dust amount for Ordinal
          inscription: inscriptionId
        }]
      }
    })
    
    return { vaultAddress, transactionId: xverse.txid }
  }
}

**Starknet Tokenization:** Create ERC-20 shares representing fractional ownership of vaulted Ordinals.

// Fractionalized Ordinals Contract (Pseudocode)
Contract FractionalizedOrdinals extends ERC20:
  
  Storage:
    ordinal_id: inscription_identifier
    total_shares: token_supply_amount
    vault_address: bitcoin_multisig_address
    oracle_floor_price: price_in_sats
    redemption_threshold: percentage // e.g., 75%
  
  Constructor(ordinal_id, total_shares, name, symbol):
    initialize_erc20(name, symbol)
    set_ordinal_id(ordinal_id)
    set_total_shares(total_shares)
    mint_shares_to_creator(total_shares)
  
  Function get_ordinal_info():
    return (ordinal_id, total_shares, vault_address, oracle_floor_price)
    
  Function update_floor_price(new_price):
    require_authorized_oracle()
    oracle_floor_price = new_price
    emit PriceUpdated(ordinal_id, new_price)
    
  Function redeem_ordinal(shares_to_burn):
    require(shares_to_burn >= total_shares * redemption_threshold / 100)
    burn_tokens(caller, shares_to_burn)
    initiate_bitcoin_withdrawal_process(caller, ordinal_id)
    emit RedemptionRequested(caller, ordinal_id)

**DeFi Integration:** Connect fractionalized Ordinal tokens to Starknet DeFi protocols.

// Vesu lending integration for Ordinal shares
const VesuIntegration = {
  async supplyOrdinalShares(contractAddress, amount, account, paymasterConfig) {
    const vesuContract = new Contract(VesuABI, VesuAddress, account)
    
    // Supply fractional Ordinal tokens as collateral with AVNU paymaster
    return account.executePaymasterTransaction(
      [vesuContract.populate('supply', [contractAddress, amount])],
      paymasterConfig.feesDetails,
      paymasterConfig.maxFee
    )
  },
  
  async borrowAgainstShares(collateralAmount, borrowAsset, account, paymasterConfig) {
    const vesuContract = new Contract(VesuABI, VesuAddress, account)
    
    return account.executePaymasterTransaction(
      [vesuContract.populate('borrow', [borrowAsset, collateralAmount * 0.6])], // 60% LTV
      paymasterConfig.feesDetails,
      paymasterConfig.maxFee
    )
  }
}

// Ekubo DEX integration for fractional trading
const EkuboIntegration = {
  async createOrdinalSharePool(ordinalShareToken, baseToken, account, paymasterConfig) {
    const ekuboContract = new Contract(EkuboABI, EkuboAddress, account)
    
    return account.executePaymasterTransaction(
      [ekuboContract.populate('create_pool', [
        ordinalShareToken,
        baseToken,
        3000, // 0.3% fee tier
        account.address
      ])],
      paymasterConfig.feesDetails,
      paymasterConfig.maxFee
    )
  }
}

**Price Oracle Integration:**

// Ordinals Price Oracle Contract (Pseudocode)
Contract OrdinalsOracle:
  
  Storage:
    floor_prices: mapping(collection_id -> price_in_sats)
    authorized_updaters: mapping(address -> boolean)
    last_updated: mapping(collection_id -> timestamp)
    price_feeds: mapping(collection_id -> external_api_endpoint)
  
  Function update_floor_price(collection_id, new_price):
    require(authorized_updaters[caller] == true)
    floor_prices[collection_id] = new_price
    last_updated[collection_id] = current_timestamp()
    emit FloorPriceUpdated(collection_id, new_price)
  
  Function get_floor_price(collection_id):
    require_recent_update(collection_id, 1_hour)
    return floor_prices[collection_id]
    
  Function add_price_feed(collection_id, api_endpoint):
    require_admin_access()
    price_feeds[collection_id] = api_endpoint

**Oracle Data Sources:**
- **Magic Eden API**: Ordinals marketplace data
- **OrdinalHub**: Comprehensive Ordinals analytics
- **Gamma . io**: NFT marketplace with Bitcoin support

#### Potential Outcome
A comprehensive fractionalized Ordinals platform that makes blue-chip Bitcoin NFTs accessible to smaller investors while creating new DeFi primitives. Users can trade fractional shares, use them as collateral, and participate in price appreciation without needing to own entire Ordinals.

#### Key Differentiators
First fractionalized Ordinals platform with DeFi integration; Native Bitcoin L1 security for underlying assets; Fractional trading with AMM liquidity; Lending/borrowing against Ordinal collateral; Price discovery for Bitcoin NFT fractions; Community governance for vault management; Seamless Xverse wallet integration; Gasless transactions via AVNU paymaster.

---

### **11) Idea: Bitcoin Runes DAO Governance Platform (by the Xverse team)**

**Track:** Bitcoin Unleashed and Open Innovation. **Problem:** Runes projects lack proper governance infrastructure. There's no way for Runes holders to participate in project decisions, vote on proposals, or coordinate community action. Most Runes projects operate without transparency or community input. **Proposal:** Build a comprehensive DAO governance platform specifically for Bitcoin Runes projects, enabling proposal creation, voting, treasury management, and transparent decision-making.

#### Key Technologies & Sponsors
Uses Starknet Asset Runes bridge, Xverse wallet for Bitcoin authentication, Starknet's native account abstraction for gasless voting, and Cairo smart contracts for governance logic.

#### Technical Architecture & Implementation

**Runes Authentication System:** Verify Runes ownership on Bitcoin L1 through Xverse wallet integration.

// Bitcoin Runes balance verification via Xverse
const RunesAuth = {
  async connectXverseWallet() {
    const xverse = await window.XverseProviders?.BitcoinProvider?.request({
      method: 'getAccounts'
    })
    return xverse?.[0]
  },
  
  async getRunesBalance(address, runeId) {
    // Query Bitcoin network for Runes balance via Hiro API
    const response = await fetch(`https://api.hiro.so/ordinals/v1/runes/balances/${address}`)
    const balances = await response.json()
    
    const runeBalance = balances.results.find(r => r.rune.id === runeId)
    return runeBalance ? parseInt(runeBalance.balance) : 0
  },
  
  async signRunesOwnership(address, runeId) {
    // Sign message proving Runes ownership
    return await window.XverseProviders.BitcoinProvider.request({
      method: 'signMessage',
      params: {
        address,
        message: `Verify ownership of Rune ${runeId} at block ${Date.now()}`
      }
    })
  }
}

**DAO Governance Contracts:**

// Main DAO Governance Contract (Pseudocode)
Contract RunesDAO:
  
  Storage:
    rune_id: rune_identifier
    total_rune_supply: total_amount_in_circulation
    proposals: mapping(proposal_id -> proposal_data)
    proposal_count: counter
    votes: mapping((proposal_id, voter_address) -> vote_data)
    member_voting_power: mapping(starknet_address -> rune_amount)
    proposal_threshold: minimum_tokens_to_propose
    quorum_threshold: minimum_participation_percentage
  
  Struct Proposal:
    id: unique_identifier
    proposer: address
    title: string
    description: string  
    start_time: timestamp
    end_time: timestamp
    for_votes: vote_count
    against_votes: vote_count
    executed: boolean
    proposal_type: (Treasury, Governance, Technical)
  
  Function create_proposal(title, description, duration, proposal_type):
    require(member_voting_power[caller] >= proposal_threshold)
    
    proposal_id = increment_proposal_count()
    current_time = get_current_timestamp()
    
    new_proposal = Proposal {
      id: proposal_id,
      proposer: caller,
      title: title,
      description: description,
      start_time: current_time,
      end_time: current_time + duration,
      proposal_type: proposal_type
    }
    
    proposals[proposal_id] = new_proposal
    emit ProposalCreated(proposal_id, caller, title)
    return proposal_id
  
  Function vote(proposal_id, support, bitcoin_signature):
    voting_power = member_voting_power[caller]
    require(voting_power > 0)
    
    verify_bitcoin_signature(caller, bitcoin_signature)
    
    proposal = proposals[proposal_id]
    require(current_time() <= proposal.end_time)
    
    // Record vote
    votes[(proposal_id, caller)] = Vote(caller, support, voting_power)
    
    // Update proposal totals
    if support:
      proposal.for_votes += voting_power
    else:
      proposal.against_votes += voting_power
      
    emit VoteCast(proposal_id, caller, support, voting_power)

**Cross-Chain Voting Interface:** Frontend that connects Bitcoin wallets to Starknet governance.

// Frontend integration for cross-chain voting with AVNU paymaster
const DAOInterface = {
  async registerRunesHolder(runeId, starknetAddress) {
    const bitcoinAddress = await RunesAuth.connectXverseWallet()
    const runesBalance = await RunesAuth.getRunesBalance(bitcoinAddress, runeId)
    
    if (runesBalance === 0) {
      throw new Error('No Runes balance found')
    }
    
    // Sign ownership proof
    const signature = await RunesAuth.signRunesOwnership(bitcoinAddress, runeId)
    
    // Setup AVNU paymaster for gasless registration
    const paymasterRpc = new PaymasterRpc({
      nodeUrl: 'https://starknet.paymaster.avnu.fi',
      headers: { 'api-key': process.env.AVNU_API_KEY }
    })
    
    const account = new Account(provider, starknetAddress, signer, undefined, undefined, paymasterRpc)
    const daoContract = new Contract(RunesDAOABI, getDaoAddress(runeId), account)
    
    const feesDetails = {
      feeMode: { mode: 'sponsored' } // DAO sponsors registration
    }
    
    return account.executePaymasterTransaction(
      [daoContract.populate('register_member', [bitcoinAddress, runesBalance, signature])],
      feesDetails
    )
  },
  
  async voteOnProposal(runeId, proposalId, support) {
    const bitcoinAddress = await RunesAuth.connectXverseWallet()
    const signature = await RunesAuth.signRunesOwnership(bitcoinAddress, runeId)
    
    const account = await setupAccountWithAVNUPaymaster()
    const daoContract = new Contract(RunesDAOABI, getDaoAddress(runeId), account)
    
    const feesDetails = {
      feeMode: { mode: 'sponsored' } // DAO sponsors voting
    }
    
    return account.executePaymasterTransaction(
      [daoContract.populate('vote', [proposalId, support, signature])],
      feesDetails
    )
  }
}

**Treasury Management:** Multi-sig treasury for DAO assets with automated execution.

// Treasury Management Contract (Pseudocode)
Contract RunesDAOTreasury:
  
  Storage:
    dao_contract: main_dao_address
    authorized_executors: mapping(address -> boolean)
    treasury_assets: mapping(token_address -> balance)
    multisig_threshold: number_of_required_signatures
  
  Function execute_treasury_proposal(proposal_id, recipient, amount, asset):
    dao = get_dao_contract()
    proposal = dao.get_proposal(proposal_id)
    
    require(proposal.for_votes > proposal.against_votes)
    require(proposal.executed == false)
    require(current_time() > proposal.end_time)
    
    // Transfer funds to recipient
    transfer_token(asset, recipient, amount)
    
    // Mark proposal as executed
    dao.mark_executed(proposal_id)
    
    emit TreasuryTransfer(proposal_id, recipient, amount, asset)

**Gasless Voting with AVNU Paymaster:**

// Setup sponsored voting for DAO members
const setupSponsoredVoting = async (daoAddress) => {
  const paymasterRpc = new PaymasterRpc({
    nodeUrl: 'https://starknet.paymaster.avnu.fi',
    headers: { 'api-key': process.env.AVNU_API_KEY }
  })
  
  // Configure sponsored transactions for DAO functions
  const sponsorConfig = {
    sponsoredFunctions: ['vote', 'create_proposal', 'register_member'],
    dailyBudget: '1000000000000000000', // 1 ETH daily budget
    contractAddresses: [daoAddress]
  }
  
  return { paymasterRpc, sponsorConfig }
}

#### Potential Outcome
A comprehensive governance platform that brings DAO functionality to the Bitcoin Runes ecosystem. Runes projects can establish transparent governance, manage community treasuries, and make collective decisions while maintaining their Bitcoin-native identity.

#### Key Differentiators
First governance platform designed specifically for Bitcoin Runes; Cross-chain voting with Bitcoin authentication and Starknet execution; Gasless voting powered by AVNU paymaster; Multi-asset treasury management; Transparent proposal and voting history; Native Xverse wallet integration; Automated execution of approved proposals; Support for multiple Runes projects on single platform.

---

### **Additional Ideas from Our Sponsors**

Here are more high-potential ideas proposed directly by our partners.

#### **From the Troves and Endur Team**
* **LST-Based Stablecoin:** Build a stablecoin protocol that uses Starknet Liquid Staking Tokens (xSTRK, xBTCs from Endur) as primary collateral.
* **Automated Yield Strategies:** Build and automate novel yield strategies for Troves. If unique and useful, the Troves team may list it and offer the builder a fee cut.
* **Yield Strategy NFT Visualizer:** Turn vault positions in Troves or Endur into dynamic NFTs where the art changes based on performance.
* **Cross-Chain Investment App:** Invest on L1 (ETH/BTC) and auto-route to Troves/Endur; support L1 withdrawals. General-purpose scope preferred.
* **Consumer Apps Using Endur/Troves:** Internally invest user funds via Endur/Troves.
* **xSTRK Re-Staking Plans:** Design and implement re-staking around xSTRK.
* **LLM-Powered Yield TG Bot:** Chat about Starknet yield opportunities; if good, used in the Troves TG group.

#### **From the Wootzapp Team**
* **PrivaPay Bitcoin Subscriptions:** Recurring payments for creators and SaaS; browser ZK subscription token authorizes private debits; priced and settled in BTC‑backed assets.
* **Satoshi Streams (Content Micropayments):** Pay‑per‑view/read/listen; browser ZK proof acts as a private ticket; payments streamed in sats with final settlement on Bitcoin L1.
* **ZK‑Verified B2B Invoicing:** Cross‑border invoices; browser ZK‑TLS proof of invoice data; invoices settled in BTC to avoid FX fees and delays.
* **Proof‑of‑Solvency BTC Escrow:** High‑value P2P asset exchange; buyer generates a ZK‑TLS proof of funds; escrowed funds held and settled in native BTC.
* **Programmable Logistics Payments:** Automated supply‑chain payments; browser ZK‑TLS proof of shipping/milestones; BTC released automatically on milestones.
* **Confidential Bitcoin Payroll:** Global payroll; employee generates a ZK proof to privately withdraw salary from a shielded pool; salaries paid in BTC.
* **Compliant Bitcoin Crowdfunding:** Regulated capital raises; investor ZK proof of accredited status; capital held in a secure BTC‑denominated treasury.
* **ZK‑Gated Bitcoin Commerce:** E‑commerce with access control; customer ZK proof of age/membership unlocks purchases; marketplace settles natively in BTC.
* **Bitcoin‑Native Gaming Economy:** In‑game economies settled in BTC; player ZK proofs for private in‑game actions; NFTs and currency priced and settled in BTC.
* **Decentralized Bitcoin Insurance:** P2P insurance pools; claimant ZK‑TLS proof of the claim event; premiums and payouts managed in a BTC‑denominated pool.