Digital Ice Mountain

PintPass

TOKEN STANDARDSPL 0-DecimalsZero fractional rounding errors
CONFIRMATION TIME~400 msSub-second reward settlement
NETWORK GAS FEE< $0.0001Micro-fractional store scale
SECURITY INVARIANTPDA SeedsNo private keys in mint path
CORE PROTOCOL CAPABILITIES

Engineered for high-throughput retail commerce

Eliminating centralized database vulnerabilities, locked-in vendor silos, and fractional rounding discrepancies.

01 / SPL STANDARDTOKEN PIPELINE

Zero decimals,
zero slippage,
true ownership.

Pure integer arithmetic standard.

Sovereign wallet custody—minted as standard SPL tokens with integer units and deterministic accounts.

TOKEN PIPELINESPL STANDARD
02 / PDA SEEDSPROGRAM SIGNER

Non-custodial,
signer-gated,
sovereign state.

Cryptographic signer verification.

Verified authority control—only authorized merchant wallet signers can trigger reward minting via PDA derivation.

AUTHORITY CONTROLPROGRAM SIGNER
03 / PROOF-OF-BURNRECEIPT PDA

Proof-of-burn,
atomic execution,
zero fraud.

Deterministic receipt stamps.

Cryptographic proof-of-burn—redemption executes an SPL burn and stamps an immutable on-chain receipt PDA with clock timestamp.

RECEIPT PDAON-CHAIN AUDIT
04 // CHECKED MATHSAFETY INVARIANT

Checked math,
safe counters,
provable state.

PointPassError invariant guarantees.

Rust checked arithmetic—math overflow triggers immediate transaction reversion across reward counters and circulation limits.

SAFETY INVARIANTANCHOR REVERSION
05 // MULTI-TENANCYPDA ISOLATION

Isolated state,
merchant seeds,
infinite scale.

Zero cross-program state contention.

Deterministic multi-tenancy—thousands of stores run simultaneously on isolated PDA seed trees with parallel Sealevel runtime.

PDA ISOLATIONPER-STORE TREE
06 // COMPOSABILITYSOLANA ECOSYSTEM

Composable dApps,
wallet native,
ecosystem wide.

Instant wallet & explorer indexing.

Open Solana composability—all accounts, tokens, and receipts are standard Solana primitives, immediately visible in Phantom and Solflare.

COMPOSABILITYSOLANA ECOSYSTEM
Pipeline04

How PointPass
executes on-chain,
step by step

From initial merchant registry to cryptographic receipt stamp, every phase executes via verifiable Solana Anchor instructions.

Deterministic PDA seeds guarantee zero merchant private key exposure across all lifecycle operations.

01 // Program Init
1 PDA

initialize_loyalty_program

Merchant configuration and zero-decimal SPL mint genesis

02 // Pass Derivation
0 Rent

get_or_create_ata

Customer pass derived deterministically; zero custodial liability

03 // Point Accrual
~400ms

award_points (CPI)

Program signer mints integer tokens to customer ATA atomically

04 // Proof-of-Burn
100%

redeem (Receipt PDA)

Tokens burned permanently; Clock timestamp audit receipt stamped

COMPARATIVE ANALYSIS MATRIX

PointPass on Solana vs Legacy Web2 Loyalty

Compare architectural differences between siloed centralized databases and sovereign on-chain SPL tokens.

Architectural DimensionLegacy Web2 Loyalty (Shopify / Square)PointPass Solana Protocol
Point CustodySiloed in private database table; merchant can delete or modify at willSelf-custodied in customer wallet as SPL tokens; mathematically sovereign
Redemption ProofDatabase decrement flag; easily disputed or replayed during chargebacksImmutable on-chain RedemptionReceipt PDA with Solana Clock timestamp
Ecosystem ComposabilityZero composability; locked into proprietary vendor APIs and closed portalsStandard SPL token; composable with DEXes, NFT gateways, and dApps
Account IsolationMulti-tenant shared SQL table; schema migration risks & single point of failureDedicated PDA accounts per merchant authority; zero shared state vulnerability
AuditabilityInternal audit logs accessible only to engineers and platform adminsPublicly auditable by any explorer, RPC node, or third-party indexer
DEVELOPER SDK & ON-CHAIN PROGRAM

Anchor Rust & Client SDK

// Burn points and stamp an immutable on-chain receipt PDA
pub fn handle_redeem(ctx: Context<Redeem>) -> Result<()> {
    let loyalty_program = &mut ctx.accounts.loyalty_program;
    let reward_cost = loyalty_program.reward_cost;

    token::burn(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            Burn {
                mint: ctx.accounts.points_mint.to_account_info(),
                from: ctx.accounts.customer_token_account.to_account_info(),
                authority: ctx.accounts.customer.to_account_info(),
            },
        ),
        reward_cost,
    )?;

    let receipt = &mut ctx.accounts.receipt;
    receipt.customer = ctx.accounts.customer.key();
    receipt.loyalty_program = loyalty_program.key();
    receipt.receipt_number = loyalty_program.redemption_count;
    receipt.points_burned = reward_cost;
    receipt.timestamp = Clock::get()?.unix_timestamp;
    receipt.bump = ctx.bumps.receipt;

    loyalty_program.total_redeemed = loyalty_program.total_redeemed.checked_add(reward_cost).ok_or(PointPassError::MathOverflow)?;
    loyalty_program.redemption_count = loyalty_program.redemption_count.checked_add(1).ok_or(PointPassError::MathOverflow)?;

    Ok(())
}
GET STARTED TODAY

Ready to deploy sovereign loyalty on Solana?

Experience zero-decimal SPL loyalty tokens on Solana Devnet. Test the customer flow or launch your own store terminal.