BurnerClient Reference

import { BurnerClient } from '@burnandclaim/sdk'
 
const client = new BurnerClient(options?: BurnerClientOptions)

async createSession(request: CreateSessionRequest): Promise<CreateSessionResponse>

interface CreateSessionResponse {
  token: string           // The session token
  expiresAt: string       // ISO 8601 expiry timestamp
  scopes: SessionScope[]  // The granted scopes
}

const session = await client.createSession({
  walletAddress: 'DRpb...xy4Z',
  scopes: ['wallet:read', 'transactions:build', 'transactions:submit'],
  ttlSeconds: 600,
})
console.log(session.token)     // "eyJhbGci..."
console.log(session.expiresAt) // "2026-04-09T12:10:00.000Z"

async getWalletAssets(walletAddress: string): Promise<WalletAssets>

interface WalletAssets {
  walletAddress: string
  items: WalletItem[]
  counts: Record<WalletItemType, number>
}
 
interface WalletItem {
  type: WalletItemType
  address: string
  name?: string
  symbol?: string
  imageUri?: string
  collection?: { address: string; name?: string }
  mint?: string           // only for empty_account
  decimals?: number
  balance?: string        // raw amount as string
  uiBalance?: number      // human-readable balance
  usdValue?: number
  tokenProgram?: string
  tokenStandard?: string
  lamports?: number       // rent held by the account
  isMetaplexResized?: boolean
  isFrozen?: boolean
  isCompressed?: boolean
  actions: BurnerAction[] // available actions for this item
}

const { items, counts } = await client.getWalletAssets(walletAddress)
 
console.log(`Found ${items.length} items`)
console.log(`Empty accounts: ${counts.empty_account}`)
console.log(`Tokens: ${counts.token}`)
 
for (const item of items) {
  console.log(`${item.name ?? item.address} - ${item.type} - actions: ${item.actions.join(', ')}`)
}

async buildTransactions(
  walletAddress: string,
  request: BuildTransactionsRequest
): Promise<BuildTransactionsResponse>

interface ItemSelection {
  type: WalletItemType
  address: string   // same address returned by getWalletAssets
  action: BurnerAction
}

interface BuildTransactionsResponse {
  transactions: BuiltTransaction[]
  recentBlockhash: string
  lastValidBlockHeight: number
  totals: {
    itemCount: number
    grossRebate: number     // lamports before fees
    netRebate: number       // lamports the user keeps
    donationAmount: number  // lamports routed to donation
    fees: number            // platform fee in lamports
  }
}
 
interface BuiltTransaction {
  transactionBase64: string     // base64 unsigned VersionedTransaction
  includes: ItemSelection[]     // which items this tx covers
  grossRebate: number
  netRebate: number
  donationAmount: number
  computeUnitsNeeded: number
  submissionTicket: string      // pass this back on submit
}

const { transactions, totals } = await client.buildTransactions(
  walletAddress,
  {
    items: [
      { type: 'empty_account', address: 'ATA111...', action: 'close' },
      { type: 'token', address: 'Mint222...', action: 'burn' },
    ],
    donationPercentage: 0.05,
  }
)
 
console.log(`${totals.itemCount} items, net rebate: ${totals.netRebate / 1e9} SOL`)

async submitTransactions(
  walletAddress: string,
  request: SubmitTransactionsRequest
): Promise<SubmitTransactionsResponse>

interface SignedTransaction {
  transactionBase64: string  // base64 signed VersionedTransaction
  submissionTicket: string   // from the build response
}

interface SubmitTransactionsResponse {
  results: SubmissionResult[]
}
 
interface SubmissionResult {
  signature: string | null
  status: 'submitted' | 'duplicate' | 'failed'
  includes: ItemSelection[]
  error?: { code: string; message: string }
}

const { results } = await client.submitTransactions(walletAddress, {
  signed: signedTransactions.map((tx, i) => ({
    transactionBase64: Buffer.from(tx.serialize()).toString('base64'),
    submissionTicket: transactions[i].submissionTicket,
  })),
})
 
for (const result of results) {
  if (result.status === 'submitted') {
    console.log(`https://solscan.io/tx/${result.signature}`)
  }
}

async *streamWalletAssets(
  walletAddress: string,
  options?: { chunkSize?: number }
): AsyncGenerator<WalletAssetsChunk>

async getStats(): Promise<ProjectBurnerStats>

interface ProjectBurnerStats {
  totalGrossRebate: number                     // SOL reclaimed before fees (lamports)
  totalNetRebate: number                       // SOL users kept after fees (lamports)
  totalTransactionCount: number                // total transactions
  transactionTypeCounts: Record<string, number> // breakdown by type
  totalReferrals: number                       // transactions via referrals
  totalReferralProfitShare: number             // profit share earned from referrals (lamports)
  totalWallets: number                         // unique wallets
  totalDonations: number                       // donation count
  totalDonationAmount: number                  // total donated (lamports)
}

const stats = await client.getStats()
console.log(`${stats.totalWallets} wallets have reclaimed ${stats.totalNetRebate / 1e9} SOL`)

async getLeaderboard(filter?: LeaderboardFilter): Promise<BurnerLeaderboardEntry[]>

interface BurnerLeaderboardEntry {
  payer: string
  totalGrossRebate: number
  totalNetRebate: number
  totalTransactionCount: number
  transactionTypeCounts: Record<string, number>
  totalDonationAmount: number
  totalDonationCount: number
  totalCommunityAmount: number
}

const leaderboard = await client.getLeaderboard({
  startDate: '2026-01-01T00:00:00Z',
  endDate: '2026-04-01T00:00:00Z',
})
 
for (const entry of leaderboard) {
  console.log(`${entry.payer}: ${entry.totalTransactionCount} burns`)
}