Code Examples

Complete code examples for common TIX Protocol operations.

Full Event Lifecycle

import { Connection, Keypair, PublicKey } from '@solana/web3.js';
import { getAssociatedTokenAddress, getOrCreateAssociatedTokenAccount } from '@solana/spl-token';
import {
  registerEvent,
  issuePermits,
  listTicket,
  acceptOffer,
  markUsed,
  getEvent,
  getPermit,
} from '@tixprotocol/sdk';

const USDC_MINT = new PublicKey('...');

async function fullEventLifecycle() {
  const connection = new Connection('https://api.devnet.solana.com', 'confirmed');
  
  // Load your integrator keypair (provided during onboarding)
  const integrator = Keypair.fromSecretKey(/* your secret key */);
  const artist = Keypair.generate();
  const buyer1 = Keypair.generate();
  const buyer2 = Keypair.generate();
  
  // 1. Create royalty recipient ATA
  const artistAta = await getOrCreateAssociatedTokenAccount(
    connection,
    integrator,
    USDC_MINT,
    artist.publicKey
  );
  
  // 2. Register event
  console.log('1. Registering event...');
  const eventId = 1001n;
  const { tx: eventTx, event } = await registerEvent({
    connection,
    payer: integrator.publicKey,
    integratorIdentity: integrator.publicKey,
    integratorAuthority: integrator.publicKey,
    eventId,
    totalSupply: 100n,
    royaltyBps: 500,
    minRoyaltyFloor: 100_000n,
    royaltyRecipients: [
      { destination: artistAta.address, bps: 500 },
    ],
  });
  eventTx.sign([integrator]);
  await connection.sendTransaction(eventTx);
  
  // 3. Issue tickets
  console.log('2. Issuing tickets...');
  const issueTx = await issuePermits({
    connection,
    payer: integrator.publicKey,
    integratorIdentity: integrator.publicKey,
    integratorAuthority: integrator.publicKey,
    eventId,
    buyers: [buyer1.publicKey, buyer2.publicKey],
  });
  issueTx.sign([integrator]);
  await connection.sendTransaction(issueTx);
  
  // 4. Buyer 1 lists ticket for resale
  console.log('3. Listing ticket for resale...');
  const buyer1Ata = await getOrCreateAssociatedTokenAccount(
    connection,
    buyer1,
    USDC_MINT,
    buyer1.publicKey
  );
  
  const listTx = await listTicket({
    connection,
    payer: buyer1.publicKey,
    eventId,
    ticketId: 0n,
    seller: buyer1.publicKey,
    askPriceMinor: 50_000_000n,  // $50
    payoutAta: buyer1Ata.address,
    expiresAt: Math.floor(Date.now() / 1000) + 86400,
    buyerAllow: null,
  });
  listTx.sign([buyer1]);
  await connection.sendTransaction(listTx);
  
  // 5. Buyer 2 purchases the listing
  console.log('4. Accepting offer...');
  const buyer2Ata = await getOrCreateAssociatedTokenAccount(
    connection,
    buyer2,
    USDC_MINT,
    buyer2.publicKey
  );
  
  const buyTx = await acceptOffer({
    connection,
    payer: buyer2.publicKey,
    eventId,
    ticketId: 0n,
    buyer: buyer2.publicKey,
    buyerUsdcAta: buyer2Ata.address,
    integratorIdentity: integrator.publicKey,
  });
  buyTx.sign([buyer2]);
  await connection.sendTransaction(buyTx);
  
  // 6. Mark ticket as used at event
  console.log('5. Marking ticket as used...');
  const usedTx = await markUsed({
    connection,
    payer: integrator.publicKey,
    eventId,
    ticketId: 0n,
    integratorIdentity: integrator.publicKey,
    integratorAuthority: integrator.publicKey,
  });
  usedTx.sign([integrator]);
  await connection.sendTransaction(usedTx);
  
  // 7. Verify final state
  console.log('6. Verifying final state...');
  const eventState = await getEvent(connection, event);
  const permit = await getPermit(connection, event, 0n);
  
  console.log(`Event minted: ${eventState.minted}/${eventState.totalSupply}`);
  console.log(`Ticket 0 owner: ${permit.owner.toBase58()}`);
  console.log(`Ticket 0 status: ${permit.status}`);
  
  console.log('Complete!');
}

Marketplace Integration

import { Connection, Keypair, PublicKey } from '@solana/web3.js';
import {
  registerEvent,
  issuePermit,
  getEvent,
  getPermit,
  eventPda,
} from '@tixprotocol/sdk';

class TicketMarketplace {
  private connection: Connection;
  private integratorIdentity: PublicKey;
  private integratorAuthority: Keypair;
  
  constructor(
    connection: Connection,
    integratorIdentity: PublicKey,
    integratorAuthority: Keypair
  ) {
    this.connection = connection;
    this.integratorIdentity = integratorIdentity;
    this.integratorAuthority = integratorAuthority;
  }
  
  async createEvent(params: {
    eventId: bigint;
    totalSupply: bigint;
    royaltyBps: number;
    minRoyaltyFloor: bigint;
    royaltyRecipients: { destination: PublicKey; bps: number }[];
  }) {
    const { tx, event } = await registerEvent({
      connection: this.connection,
      payer: this.integratorAuthority.publicKey,
      integratorIdentity: this.integratorIdentity,
      integratorAuthority: this.integratorAuthority.publicKey,
      ...params,
    });
    
    tx.sign([this.integratorAuthority]);
    const sig = await this.connection.sendTransaction(tx);
    
    return { signature: sig, event };
  }
  
  async purchaseTicket(
    eventId: bigint,
    buyerWallet: PublicKey
  ) {
    // Get current event state
    const [eventPubkey] = eventPda(eventId);
    const event = await getEvent(this.connection, eventPubkey);
    
    // Check availability
    if (event.minted >= event.totalSupply) {
      throw new Error('Event is sold out');
    }
    
    // Issue next ticket
    const ticketId = event.minted;
    const tx = await issuePermit({
      connection: this.connection,
      payer: this.integratorAuthority.publicKey,
      integratorIdentity: this.integratorIdentity,
      integratorAuthority: this.integratorAuthority.publicKey,
      eventId,
      buyer: buyerWallet,
      ticketId,
    });
    
    tx.sign([this.integratorAuthority]);
    const sig = await this.connection.sendTransaction(tx);
    
    return {
      signature: sig,
      ticketId,
      owner: buyerWallet,
    };
  }
  
  async getEventStats(eventId: bigint) {
    const [eventPubkey] = eventPda(eventId);
    const event = await getEvent(this.connection, eventPubkey);
    
    return {
      totalSupply: Number(event.totalSupply),
      minted: Number(event.minted),
      remaining: Number(event.totalSupply - event.minted),
      percentageSold: (Number(event.minted) / Number(event.totalSupply)) * 100,
      royaltyBps: event.royaltyBps,
    };
  }
  
  async getTicketDetails(eventId: bigint, ticketId: bigint) {
    const [eventPubkey] = eventPda(eventId);
    const permit = await getPermit(this.connection, eventPubkey, ticketId);
    
    return {
      ticketId: Number(permit.ticketId),
      owner: permit.owner.toBase58(),
      status: permit.status,
      version: Number(permit.version),
      isLocked: permit.isLocked,
    };
  }
}

// Usage
const marketplace = new TicketMarketplace(connection, integratorIdentity, integratorAuthority);

// Create event
const { event } = await marketplace.createEvent({
  eventId: 2001n,
  totalSupply: 500n,
  royaltyBps: 750,
  minRoyaltyFloor: 150_000n,
  royaltyRecipients: [{ destination: artistAta, bps: 750 }],
});

// Sell tickets
const ticket1 = await marketplace.purchaseTicket(2001n, customer1.publicKey);
const ticket2 = await marketplace.purchaseTicket(2001n, customer2.publicKey);

// Check stats
const stats = await marketplace.getEventStats(2001n);
console.log(`${stats.percentageSold.toFixed(1)}% sold`);

Secondary Market Bot

import { Connection, Keypair, PublicKey } from '@solana/web3.js';
import {
  getListing,
  getPermit,
  acceptOffer,
  listingPda,
  eventPda,
} from '@tixprotocol/sdk';

class ResaleBot {
  private connection: Connection;
  private buyer: Keypair;
  private buyerUsdcAta: PublicKey;
  private integratorIdentity: PublicKey;
  
  constructor(
    connection: Connection,
    buyer: Keypair,
    buyerUsdcAta: PublicKey,
    integratorIdentity: PublicKey
  ) {
    this.connection = connection;
    this.buyer = buyer;
    this.buyerUsdcAta = buyerUsdcAta;
    this.integratorIdentity = integratorIdentity;
  }
  
  async checkListing(eventId: bigint, ticketId: bigint) {
    const [listingPubkey] = listingPda(eventId, ticketId);
    const [eventPubkey] = eventPda(eventId);
    
    try {
      const listing = await getListing(this.connection, listingPubkey);
      const permit = await getPermit(this.connection, eventPubkey, ticketId);
      
      const now = Math.floor(Date.now() / 1000);
      
      return {
        exists: true,
        active: listing.active,
        expired: listing.expiresAt < now,
        versionMatch: listing.permitVersion === permit.version,
        askPrice: listing.askPriceMinor,
        seller: listing.seller,
        canBuy: listing.active && listing.expiresAt > now && listing.permitVersion === permit.version,
      };
    } catch {
      return { exists: false };
    }
  }
  
  async buyIfUnderPrice(
    eventId: bigint,
    ticketId: bigint,
    maxPriceMinor: bigint
  ) {
    const check = await this.checkListing(eventId, ticketId);
    
    if (!check.exists || !check.canBuy) {
      return { success: false, reason: 'Listing not available' };
    }
    
    if (check.askPrice > maxPriceMinor) {
      return { 
        success: false, 
        reason: `Price ${check.askPrice} exceeds max ${maxPriceMinor}` 
      };
    }
    
    // Execute purchase
    const tx = await acceptOffer({
      connection: this.connection,
      payer: this.buyer.publicKey,
      eventId,
      ticketId,
      buyer: this.buyer.publicKey,
      buyerUsdcAta: this.buyerUsdcAta,
      integratorIdentity: this.integratorIdentity,
    });
    
    tx.sign([this.buyer]);
    const sig = await this.connection.sendTransaction(tx);
    
    return {
      success: true,
      signature: sig,
      pricePaid: check.askPrice,
    };
  }
  
  async scanForDeals(
    eventId: bigint,
    ticketIdRange: [bigint, bigint],
    maxPriceMinor: bigint
  ) {
    const deals = [];
    
    for (let ticketId = ticketIdRange[0]; ticketId <= ticketIdRange[1]; ticketId++) {
      const check = await this.checkListing(eventId, ticketId);
      
      if (check.exists && check.canBuy && check.askPrice <= maxPriceMinor) {
        deals.push({
          ticketId,
          price: check.askPrice,
          seller: check.seller,
        });
      }
    }
    
    return deals.sort((a, b) => Number(a.price - b.price));
  }
}

// Usage
const bot = new ResaleBot(connection, buyerKeypair, buyerUsdcAta, integratorIdentity);

// Find deals under $50
const deals = await bot.scanForDeals(1001n, [0n, 99n], 50_000_000n);
console.log(`Found ${deals.length} deals under $50`);

// Buy cheapest deal
if (deals.length > 0) {
  const result = await bot.buyIfUnderPrice(1001n, deals[0].ticketId, 50_000_000n);
  console.log(result);
}

Venue Check-In System

import { Connection, Keypair, PublicKey } from '@solana/web3.js';
import {
  getPermit,
  markUsed,
  eventPda,
} from '@tixprotocol/sdk';

class VenueCheckIn {
  private connection: Connection;
  private integratorIdentity: PublicKey;
  private integratorAuthority: Keypair;
  private eventId: bigint;
  
  constructor(
    connection: Connection,
    integratorIdentity: PublicKey,
    integratorAuthority: Keypair,
    eventId: bigint
  ) {
    this.connection = connection;
    this.integratorIdentity = integratorIdentity;
    this.integratorAuthority = integratorAuthority;
    this.eventId = eventId;
  }
  
  async validateTicket(ticketId: bigint, expectedOwner: PublicKey) {
    const [eventPubkey] = eventPda(this.eventId);
    const permit = await getPermit(this.connection, eventPubkey, ticketId);
    
    const errors = [];
    
    if (!permit.owner.equals(expectedOwner)) {
      errors.push(`Owner mismatch: expected ${expectedOwner.toBase58()}, got ${permit.owner.toBase58()}`);
    }
    
    if (permit.status !== 'Active') {
      errors.push(`Ticket is ${permit.status}`);
    }
    
    return {
      valid: errors.length === 0,
      errors,
      permit,
    };
  }
  
  async checkIn(ticketId: bigint, holderWallet: PublicKey) {
    // Validate first
    const validation = await this.validateTicket(ticketId, holderWallet);
    
    if (!validation.valid) {
      return {
        success: false,
        errors: validation.errors,
      };
    }
    
    // Mark as used
    const tx = await markUsed({
      connection: this.connection,
      payer: this.integratorAuthority.publicKey,
      eventId: this.eventId,
      ticketId,
      integratorIdentity: this.integratorIdentity,
      integratorAuthority: this.integratorAuthority.publicKey,
    });
    
    tx.sign([this.integratorAuthority]);
    const sig = await this.connection.sendTransaction(tx);
    
    return {
      success: true,
      signature: sig,
      ticketId: Number(ticketId),
      checkedInAt: new Date(),
    };
  }
  
  async batchCheckIn(tickets: { ticketId: bigint; wallet: PublicKey }[]) {
    const results = [];
    
    for (const ticket of tickets) {
      try {
        const result = await this.checkIn(ticket.ticketId, ticket.wallet);
        results.push({ ...ticket, ...result });
      } catch (error) {
        results.push({
          ...ticket,
          success: false,
          error: error.message,
        });
      }
    }
    
    return {
      total: tickets.length,
      successful: results.filter(r => r.success).length,
      failed: results.filter(r => !r.success).length,
      results,
    };
  }
}

// Usage
const checkIn = new VenueCheckIn(
  connection,
  integratorIdentity,
  integratorAuthority,
  1001n
);

// Single check-in
const result = await checkIn.checkIn(42n, fanWallet);
if (result.success) {
  console.log(`Welcome! Ticket ${result.ticketId} checked in.`);
} else {
  console.error('Check-in failed:', result.errors);
}