Secondary Marketplace

This guide covers peer-to-peer transfers, listing tickets for resale, and executing secondary market purchases.

Overview

TIX Protocol supports two types of secondary market operations:

1. Direct Transfers — Send tickets directly to another wallet

2. Resale Listings — List tickets for sale with automatic royalty distribution

Direct Transfers

Transfer a Ticket

The ticket owner (or integrator authority) can transfer directly:

import { transferPermit } from "@tixprotocol/sdk";

const tx = await transferPermit({
  connection,
  payer: currentOwner.publicKey,
  eventId: 1n,
  ticketId: 42n,
  currentOwner: currentOwner.publicKey,
  newOwner: friendWallet.publicKey,
  integratorIdentity: marketplace.publicKey,
});

tx.sign([currentOwner]);
await connection.sendTransaction(tx);

Who Can Transfer?

Actor	Can Transfer?	Notes
Current owner	✅	Standard transfer
Integrator authority	✅	Facilitated transfer
Anyone else	❌	Unauthorized

Transfer Fee

Direct transfers incur the p2p_transfer_fee:

• Deducted from integrator treasury

• No royalties on direct transfers

• Fee goes to protocol vault

Resale Listings

List a Ticket for Sale

import { listTicket } from "@tixprotocol/sdk";

const tx = await listTicket({
  connection,
  payer: seller.publicKey,
  eventId: 1n,
  ticketId: 42n,
  seller: seller.publicKey,
  askPriceMinor: 150_000_000n, // $150 in USDC minor units
  payoutAta: sellerUsdcAta,
  expiresAt: Math.floor(Date.now() / 1000) + 86400, // 24 hours
  buyerAllow: null, // Open to all buyers
});

tx.sign([seller]);
await connection.sendTransaction(tx);

Listing Options

Parameter	Type	Description
askPriceMinor	bigint	Sale price in USDC minor units
payoutAta	PublicKey	Seller's USDC ATA for payment
expiresAt	number	Unix timestamp for expiration
buyerAllow	PublicKey | null	Optional: restrict to specific buyer

Private Sales

List to a specific buyer only:

const tx = await listTicket({
  // ... other params
  buyerAllow: specificBuyer.publicKey, // Only this wallet can buy
});

What Happens on Listing

1. Listing account created — Stores sale details

2. Permit locked — padding[0] = 1 blocks direct transfers

3. Expiry cached — Stored in permit for validation

┌─────────────────────────────────────────────────────────────┐
│                    LISTING FLOW                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Seller                Permit                  Listing      │
│  ┌─────────┐          ┌─────────────┐        ┌──────────┐   │
│  │ signs   │────────▶ │ locked      │───────▶│ created  │   │
│  │ listTx  │          │ padding[0]=1│        │ active   │   │
│  └─────────┘          └─────────────┘        └──────────┘   │
│                                                             │
│  Ticket cannot be transferred while listing is active       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Accepting Offers (Buying)

Purchase a Listed Ticket

import { acceptOffer } from "@tixprotocol/sdk";

const tx = await acceptOffer({
  connection,
  payer: buyer.publicKey,
  eventId: 1n,
  ticketId: 42n,
  buyer: buyer.publicKey,
  buyerUsdcAta: buyerUsdcAta,
  integratorIdentity: marketplace.publicKey,
});

tx.sign([buyer]);
await connection.sendTransaction(tx);

Payment Flow on Purchase

┌─────────────────────────────────────────────────────────────┐
│              ACCEPT OFFER PAYMENT FLOW                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Buyer pays $100                                            │
│       │                                                     │
│       ├────▶ Royalties (5%)                                 │
│       │      ├── Artist ATA: $3.00 (300 bps)                │
│       │      └── Venue ATA:  $2.00 (200 bps)                │
│       │                                                     │
│       └────▶ Seller receives: $95.00                        │
│                                                             │
│  Integrator treasury pays:                                  │
│       └────▶ Resale fee (1%): $1.00 → Protocol vault        │
│                                                             │
│  Ownership transfers:                                       │
│       └────▶ permit.owner = buyer.publicKey                 │
│                                                             │
│  Listing cleared:                                           │
│       └────▶ permit.padding[0] = 0 (unlocked)               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

What's Validated on Purchase

Check	Error if Failed
Listing is active	ListingNotActive
Listing not expired	ListingExpired
Permit version matches	ListingVersionMismatch
Buyer is allowed (if set)	Unauthorized
Buyer has sufficient USDC	Transfer fails
Permit is active	PermitNotActive

Cancelling Listings

Cancel as Seller

import { cancelListing } from "@tixprotocol/sdk";

const tx = await cancelListing({
  connection,
  payer: seller.publicKey,
  eventId: 1n,
  ticketId: 42n,
  authority: seller.publicKey, // Seller cancelling own listing
});

tx.sign([seller]);
await connection.sendTransaction(tx);

Who Can Cancel?

Actor	Can Cancel?
Seller (listing creator)	✅
Integrator authority	✅
Protocol authority	✅
Anyone else	❌

What Happens on Cancel

1. Listing deactivated — listing.active = false

2. Permit unlocked — padding[0] = 0

3. Ticket transferable — Can be transferred or re-listed

User Journeys

Journey: Fan Resells Ticket

┌─────────────────────────────────────────────────────────────┐
│               FAN RESALE JOURNEY                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Bob can't attend the concert                            │
│                                                             │
│  2. Bob opens marketplace app, selects ticket               │
│                                                             │
│  3. Bob sets ask price ($150) and lists ticket              │
│     └── listTicket transaction submitted                    │
│                                                             │
│  4. Carol finds Bob's listing on marketplace                │
│                                                             │
│  5. Carol clicks "Buy" and confirms transaction             │
│     └── acceptOffer transaction submitted                   │
│                                                             │
│  6. Payment split automatically:                            │
│     ├── $7.50 royalties to artist/venue                     │
│     └── $142.50 to Bob's wallet                             │
│                                                             │
│  7. Carol now owns the ticket                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Journey: Private Transfer

┌─────────────────────────────────────────────────────────────┐
│              PRIVATE TRANSFER JOURNEY                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. Dan bought two tickets                                  │
│                                                             │
│  2. Dan wants to give one to his friend Eve                 │
│                                                             │
│  3. Dan gets Eve's wallet address                           │
│                                                             │
│  4. Dan initiates transfer in app                           │
│     └── transferPermit transaction submitted                │
│                                                             │
│  5. Integrator treasury pays transfer fee                   │
│     └── No royalties on direct transfer                     │
│                                                             │
│  6. Eve now owns the ticket                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Listing Expiration

How Expiration Works

• Listings have an expiresAt timestamp

• Expired listings cannot be purchased

• Expired listings can be cancelled to unlock the permit

• Direct transfers are allowed if listing has expired

// Check if listing is expired
const listing = await getListing(connection, listingPda);
const now = Math.floor(Date.now() / 1000);
const isExpired = listing.expiresAt < now;

Handling Expired Listings

// Try to cancel expired listing to clean up
if (isExpired) {
  const cancelTx = await cancelListing({
    connection,
    payer: anyone.publicKey, // Anyone can clean up
    eventId: 1n,
    ticketId: 42n,
    authority: integratorAuthority.publicKey,
  });
  cancelTx.sign([integratorAuthority]);
  await connection.sendTransaction(cancelTx);
}

Complete Example

Full Resale Flow

import {
  listTicket,
  acceptOffer,
  getListing,
  getPermit,
} from "@tixprotocol/sdk";

async function resaleFlow() {
  // 1. Seller lists ticket
  const listTx = await listTicket({
    connection,
    payer: seller.publicKey,
    eventId: 1n,
    ticketId: 42n,
    seller: seller.publicKey,
    askPriceMinor: 100_000_000n, // $100
    payoutAta: sellerUsdcAta,
    expiresAt: Math.floor(Date.now() / 1000) + 7 * 24 * 3600, // 1 week
    buyerAllow: null,
  });
  listTx.sign([seller]);
  await connection.sendTransaction(listTx);

  // 2. Verify listing
  const listing = await getListing(connection, listingPda);
  console.log(`Listed for: ${listing.askPriceMinor / 1_000_000n} USDC`);

  // 3. Buyer purchases
  const buyTx = await acceptOffer({
    connection,
    payer: buyer.publicKey,
    eventId: 1n,
    ticketId: 42n,
    buyer: buyer.publicKey,
    buyerUsdcAta: buyerUsdcAta,
    integratorIdentity: marketplace.publicKey,
  });
  buyTx.sign([buyer]);
  await connection.sendTransaction(buyTx);

  // 4. Verify ownership transfer
  const permit = await getPermit(connection, eventPda, 42n);
  console.log(`New owner: ${permit.owner.toBase58()}`);
  // Should equal buyer.publicKey
}

Error Handling

Common secondary market errors:

Error	Cause	Solution
ListingActive	Trying to transfer listed ticket	Cancel listing first
ListingExpired	Listing past expiry	Seller re-lists, buyer finds another
ListingVersionMismatch	Ticket changed since listing	Re-fetch and retry
Unauthorized	Wrong signer or not on allowlist	Check permissions
PermitNotActive	Ticket is used/voided	Cannot sell used tickets
InsufficientFunds	Buyer lacks USDC	Fund buyer wallet

Next Steps

• Integrator Guide — Complete integrator operations

• Fees & Royalties — Understand payment flows

• Security — Security considerations