Skip to main content

Overview

Three ways to integrate: embed in the App Store iframe, hit the REST API, or talk to contracts directly. For full code, see GitHub.

Architecture

Integration Options

MethodUse CaseComplexity
App Store EmbedRun app in Elata iframeLow
REST APIRead app data, metadataMedium
Smart ContractsDirect blockchain interactionHigh

App Store API

The App Store provides REST endpoints for reading data.

Base URL

https://app.elata.bio/api

Endpoints

Get All Apps

GET /api/apps
Returns list of all apps with metadata:
{
  "apps": [
    {
      "id": "...",
      "tokenAddress": "0x...",
      "name": "NeuroPong",
      "symbol": "NPONG",
      "description": "...",
      "imageUrl": "...",
      "creator": "0x...",
      "status": "raising" | "live",
      "createdAt": "2024-01-01T00:00:00Z"
    }
  ]
}

Get Single App

GET /api/apps/{tokenAddress}
Returns detailed app information including:
  • Basic metadata
  • Social links
  • Team members
  • Artifacts (game files)

Get Prices

GET /api/prices
Returns current ELTA price data for UI display.

Smart Contracts

For direct blockchain interaction, these are the key contracts:

Core Contracts

ContractPurpose
ELTAMain protocol token
VeELTAVote-escrowed staking
AppFactoryCreates new apps
AppFactoryViewsRead app data

Per-App Contracts

ContractPurpose
AppTokenIndividual app token
AppBondingCurvePrice discovery
AppStakingVaultStaking for rewards
AppAccess1155NFT items
TournamentCompetition infrastructure

Contract Addresses

See Resources → Contracts for deployed addresses.

Reading On-Chain Data

import { createPublicClient, http } from 'viem'
import { baseSepolia } from 'viem/chains' // Use 'base' for mainnet

const client = createPublicClient({
  chain: baseSepolia,
  transport: http()
})

// Read app data from factory
const appData = await client.readContract({
  address: APP_FACTORY_ADDRESS,
  abi: AppFactoryABI,
  functionName: 'apps',
  args: [appId]
})

Key Read Functions

ContractFunctionReturns
AppFactoryapps(uint256)App tuple (creator, token, vault, curve, etc.)
AppFactoryappCount()Total apps launched
AppTokenbalanceOf(address)User token balance
AppStakingVaultbalanceOf(address)User staked balance
AppBondingCurvegetPrice()Current curve price
VeELTAbalanceOf(address)User veELTA balance

Writing Transactions

App Launch

import { writeContract } from 'wagmi'

// Approve ELTA first
await writeContract({
  address: ELTA_ADDRESS,
  abi: ERC20ABI,
  functionName: 'approve',
  args: [APP_FACTORY_ADDRESS, 110n * 10n**18n]
})

// Create app
await writeContract({
  address: APP_FACTORY_ADDRESS,
  abi: AppFactoryABI,
  functionName: 'createApp',
  args: [name, symbol, 0n, description, imageUrl, website]
})

Buy on Bonding Curve

// Approve ELTA for curve
await writeContract({
  address: ELTA_ADDRESS,
  abi: ERC20ABI,
  functionName: 'approve',
  args: [CURVE_ADDRESS, amount]
})

// Buy tokens
await writeContract({
  address: CURVE_ADDRESS,
  abi: AppBondingCurveABI,
  functionName: 'buy',
  args: [eltaAmount, minTokensOut]
})

Stake Tokens

// Approve tokens for vault
await writeContract({
  address: APP_TOKEN_ADDRESS,
  abi: ERC20ABI,
  functionName: 'approve',
  args: [VAULT_ADDRESS, amount]
})

// Stake
await writeContract({
  address: VAULT_ADDRESS,
  abi: AppStakingVaultABI,
  functionName: 'stake',
  args: [amount]
})

Embedding in Iframe

Apps run inside an iframe on the Elata App Store. Your app can:

Communicate with Parent

// Send message to Elata frame
window.parent.postMessage({
  type: 'ELATA_EVENT',
  payload: { action: 'SCORE_UPDATE', score: 1000 }
}, '*')

// Listen for messages from Elata
window.addEventListener('message', (event) => {
  if (event.data.type === 'ELATA_USER') {
    const { address, balance } = event.data.payload
    // Use user data
  }
})

Access User Data

When embedded, your app receives:
  • Connected wallet address
  • App token balance
  • Staked amount
  • Owned items

Webhooks (Coming Soon)

Future webhook support for:
  • New token purchases
  • Staking events
  • Tournament entries
  • Item purchases

SDKs & Libraries

Official Packages

PackagePurposeStatus
@elata/sdkTypeScript SDKPlanned
@elata/reactReact hooksPlanned

Current Approach

Use the App Store source as reference:

Useful Hooks from App Store

The App Store includes React hooks you can reference:
// Examples from elata-appstore/src/hooks/

useAppFactory()      // App creation and data
useBondingCurve()    // Price quotes, buy/sell
useAppHoldings()     // User balances
useVeELTA()          // veELTA staking
useTournament()      // Tournament interactions

ABIs

Contract ABIs are available in the App Store repository:
elata-appstore/src/abi/
├── AppFactory.json
├── AppBondingCurve.json
├── AppToken.json
├── AppStakingVault.json
├── AppAccess1155.json
├── Tournament.json
├── ELTA.json
├── VeELTA.json
└── ...

Rate Limits

API Limits

EndpointLimit
Read endpoints100 req/min
Heavy queries10 req/min

RPC Limits

Use your own RPC provider for production:

Example: Price Display Widget

import { useReadContract } from 'wagmi'
import { formatEther } from 'viem'

function PriceWidget({ curveAddress }) {
  const { data: price } = useReadContract({
    address: curveAddress,
    abi: AppBondingCurveABI,
    functionName: 'getPrice',
  })
  
  return (
    <div>
      Current Price: {price ? formatEther(price) : '...'} ELTA
    </div>
  )
}

Resources