Account Fetchers

The SDK provides fetcher functions to read and parse on-chain account data into typed objects.

Protocol Config

getProtocolConfig

Fetch the protocol configuration.

import { getProtocolConfig, protocolConfigPda } from '@tixprotocol/sdk';

const [protocolConfigPubkey] = protocolConfigPda();
const config = await getProtocolConfig(connection, protocolConfigPubkey);

console.log(`USDC Mint: ${config.usdcMint.toBase58()}`);
console.log(`Authority: ${config.authority.toBase58()}`);
console.log(`Permit Fee: ${config.permitFeeMinor} minor units`);
console.log(`Transfer Fee: ${config.p2pTransferFeeMinor} minor units`);
console.log(`Resale Fee: ${config.resaleFeeBps} bps`);

Returns:

interface ProtocolConfig {
  usdcMint: PublicKey;
  defaultRoyaltyVault: PublicKey;
  authority: PublicKey;
  usdcDecimals: number;
  permitFeeMinor: bigint;
  p2pTransferFeeMinor: bigint;
  resaleFeeBps: number;
}

Integrator

getIntegrator

Fetch an integrator account.

import { getIntegrator, integratorPda } from '@tixprotocol/sdk';

const [integratorPubkey] = integratorPda(integratorIdentity);
const integrator = await getIntegrator(connection, integratorPubkey);

console.log(`Authority: ${integrator.authority.toBase58()}`);
console.log(`Status: ${integrator.status}`);
console.log(`Treasury: ${integrator.treasuryUsdc.toBase58()}`);

Returns:

interface Integrator {
  authority: PublicKey;
  status: IntegratorStatus;  // 'Active' | 'Suspended'
  treasuryUsdc: PublicKey;
}

Check Integrator Status

const integrator = await getIntegrator(connection, integratorPubkey);

if (integrator.status === 'Suspended') {
  console.error('Integrator is suspended');
  return;
}

Event

getEvent

Fetch an event account.

import { getEvent, eventPda } from '@tixprotocol/sdk';

const [eventPubkey] = eventPda(eventId);
const event = await getEvent(connection, eventPubkey);

console.log(`Integrator: ${event.integrator.toBase58()}`);
console.log(`Total Supply: ${event.totalSupply}`);
console.log(`Minted: ${event.minted}`);
console.log(`Remaining: ${event.totalSupply - event.minted}`);
console.log(`Royalty BPS: ${event.royaltyBps}`);
console.log(`Min Royalty Floor: ${event.minRoyaltyFloor}`);
console.log(`Royalty Recipients: ${event.royaltyRecipients.length}`);

Returns:

interface Event {
  integrator: PublicKey;
  integratorAuthority: PublicKey;
  royaltyBps: number;
  minRoyaltyFloor: bigint;
  royaltyRecipients: RoyaltyRecipient[];
  totalSupply: bigint;
  minted: bigint;
  sealed: boolean;
}

interface RoyaltyRecipient {
  destination: PublicKey;
  bps: number;
}

Check Event Capacity

const event = await getEvent(connection, eventPubkey);

const remaining = event.totalSupply - event.minted;
const percentageSold = (Number(event.minted) / Number(event.totalSupply)) * 100;

console.log(`${remaining} tickets remaining (${percentageSold.toFixed(1)}% sold)`);

if (remaining === 0n) {
  console.log('Event is sold out!');
}

Permit

getPermit

Fetch a specific permit from a page.

import { getPermit, eventPda } from '@tixprotocol/sdk';

const [eventPubkey] = eventPda(eventId);
const permit = await getPermit(connection, eventPubkey, ticketId);

console.log(`Owner: ${permit.owner.toBase58()}`);
console.log(`Status: ${permit.status}`);  // 'Active' | 'Used' | 'Void'
console.log(`Version: ${permit.version}`);
console.log(`Ticket ID: ${permit.ticketId}`);
console.log(`Is Locked: ${permit.isLocked}`);

Returns:

interface Permit {
  owner: PublicKey;
  status: PermitStatus;  // 'Active' | 'Used' | 'Void'
  version: bigint;
  ticketId: bigint;
  isLocked: boolean;
  lockExpiry: number | null;
}

Check Permit Status

const permit = await getPermit(connection, eventPubkey, ticketId);

if (permit.status !== 'Active') {
  console.error(`Permit is ${permit.status}, cannot transfer`);
  return;
}

if (permit.isLocked) {
  const now = Math.floor(Date.now() / 1000);
  if (permit.lockExpiry && permit.lockExpiry > now) {
    console.error('Permit is locked by active listing');
    return;
  }
}

Get Multiple Permits

async function getPermitsForEvent(
  connection: Connection,
  eventPubkey: PublicKey,
  ticketIds: bigint[]
): Promise<Permit[]> {
  const permits = await Promise.all(
    ticketIds.map(ticketId => getPermit(connection, eventPubkey, ticketId))
  );
  return permits;
}

// Usage
const permits = await getPermitsForEvent(connection, eventPubkey, [0n, 1n, 2n]);

Listing

getListing

Fetch a listing account.

import { getListing, listingPda } from '@tixprotocol/sdk';

const [listingPubkey] = listingPda(eventId, ticketId);
const listing = await getListing(connection, listingPubkey);

console.log(`Seller: ${listing.seller.toBase58()}`);
console.log(`Ask Price: ${listing.askPriceMinor} minor units`);
console.log(`Buyer Allow: ${listing.buyerAllow?.toBase58() ?? 'Open'}`);
console.log(`Payout ATA: ${listing.payoutAta.toBase58()}`);
console.log(`Expires At: ${new Date(listing.expiresAt * 1000)}`);
console.log(`Listed At: ${new Date(listing.listedAt * 1000)}`);
console.log(`Permit Version: ${listing.permitVersion}`);
console.log(`Active: ${listing.active}`);

Returns:

interface Listing {
  seller: PublicKey;
  askPriceMinor: bigint;
  buyerAllow: PublicKey | null;
  payoutAta: PublicKey;
  expiresAt: number;
  listedAt: number;
  permitVersion: bigint;
  active: boolean;
}

Check Listing Validity

const listing = await getListing(connection, listingPubkey);
const permit = await getPermit(connection, eventPubkey, ticketId);
const now = Math.floor(Date.now() / 1000);

// Check if listing is valid for purchase
if (!listing.active) {
  console.error('Listing is not active');
  return false;
}

if (listing.expiresAt < now) {
  console.error('Listing has expired');
  return false;
}

if (listing.permitVersion !== permit.version) {
  console.error('Listing is stale (permit changed)');
  return false;
}

console.log('Listing is valid for purchase');
return true;

Error Handling

Account Not Found

try {
  const event = await getEvent(connection, eventPubkey);
} catch (error) {
  if (error.message.includes('Account does not exist')) {
    console.error('Event not found - may not be registered yet');
  }
}

Null Checks

const listing = await getListing(connection, listingPubkey);

// Handle optional buyer restriction
if (listing.buyerAllow) {
  console.log(`Restricted to buyer: ${listing.buyerAllow.toBase58()}`);
} else {
  console.log('Open to all buyers');
}

Batch Fetching

Fetch All Event Data

async function getCompleteEventData(
  connection: Connection,
  eventId: bigint
) {
  const [eventPubkey] = eventPda(eventId);
  const event = await getEvent(connection, eventPubkey);
  
  // Calculate number of pages
  const pageCount = Math.ceil(Number(event.minted) / 128);
  
  // Fetch all permits (simplistic - in production, paginate)
  const permits: Permit[] = [];
  for (let i = 0n; i < event.minted; i++) {
    const permit = await getPermit(connection, eventPubkey, i);
    permits.push(permit);
  }
  
  return {
    event,
    permits,
    stats: {
      totalSupply: event.totalSupply,
      minted: event.minted,
      active: permits.filter(p => p.status === 'Active').length,
      used: permits.filter(p => p.status === 'Used').length,
      voided: permits.filter(p => p.status === 'Void').length,
    },
  };
}