Alien Solana SSO Core API Reference: AlienSolanaSsoClient

new AlienSolanaSsoClient(config: AlienSolanaSsoClientConfig)

const client = new AlienSolanaSsoClient({
  ssoBaseUrl: 'https://sso.alien-api.com',
  providerAddress: 'platform-provider-address',
});

async generateDeeplink(solanaAddress: string): Promise<SolanaLinkResponse>

{
  deep_link: string;      // deep link for a QR code or mobile redirect
  polling_code: string;   // code for polling the linking status
  expired_at: number;     // Unix timestamp when the polling code expires
}

const userPublicKey = wallet.publicKey.toBase58();
const { deep_link, polling_code } = await client.generateDeeplink(userPublicKey);
 
displayQRCode(deep_link);

async pollAuth(pollingCode: string): Promise<SolanaPollResponse>

{
  status: 'pending' | 'authorized' | 'rejected' | 'expired';
  oracle_signature?: string;      // oracle signature (hex-encoded string)
  oracle_public_key?: string;     // oracle public key (hex-encoded string)
  solana_address?: string;        // wallet address the attestation is for
  timestamp?: number;             // Unix timestamp signed by the oracle
  session_address?: string;       // session identifier
}

const response = await client.pollAuth(polling_code);
 
if (response.status === 'authorized') {
  console.log('Session address:', response.session_address);
  console.log('Oracle signature:', response.oracle_signature);
  console.log('Timestamp:', response.timestamp);
}

async getAttestation(solanaAddress: string): Promise<string | null>

const sessionAddress = await client.getAttestation(wallet.publicKey.toBase58());
 
if (sessionAddress) {
  // Wallet already has a linking attestation — skip the creation flow
  console.log('Wallet is already linked. Session:', sessionAddress);
} else {
  // No attestation — start the flow with generateDeeplink()
  console.log('No attestation found, need to create one');
}

async buildCreateAttestationTransaction(params: BuildAttestationParams): Promise<Transaction>

interface BuildAttestationParams {
  connection: Connection;          // Solana RPC connection
  payerPublicKey: PublicKey;       // user's wallet public key
  sessionAddress: string;          // session address from the poll response
  oracleSignature: Uint8Array;     // oracle signature, hex-decoded from the poll response
  oraclePublicKey: PublicKey;      // oracle public key, hex-decoded from the poll response
  timestamp: number;               // timestamp from the poll response (oracle-signed)
  expiry: number;                  // client-supplied; pass 0 (see below)
}

import { Connection, PublicKey } from '@solana/web3.js';
import { Buffer } from 'buffer';
 
const connection = new Connection('https://api.mainnet-beta.solana.com');
 
const transaction = await client.buildCreateAttestationTransaction({
  connection,
  payerPublicKey: wallet.publicKey,
  sessionAddress: pollResponse.session_address!,
  oracleSignature: Uint8Array.from(Buffer.from(pollResponse.oracle_signature!, 'hex')),
  oraclePublicKey: new PublicKey(Buffer.from(pollResponse.oracle_public_key!, 'hex')),
  timestamp: pollResponse.timestamp!,
  expiry: 0, // currently unused — not signed by the oracle or validated on-chain
});
 
// Set the blockhash and fee payer, then sign and send
const { blockhash } = await connection.getLatestBlockhash();
transaction.recentBlockhash = blockhash;
transaction.feePayer = wallet.publicKey;
const signedTransaction = await wallet.signTransaction(transaction);
const signature = await connection.sendRawTransaction(
  signedTransaction.serialize()
);
await connection.confirmTransaction(signature);

import { Connection, PublicKey } from '@solana/web3.js';
import { Buffer } from 'buffer';
 
// Program IDs as PublicKey instances — readonly fields on the client
// (defaults listed in the Solana Programs table below)
const { credentialSignerProgramId, sasProgramId } = client;
 
// 1. Read the credential and schema addresses from program state
const [programStatePda] = PublicKey.findProgramAddressSync(
  [Buffer.from('program_state')],
  credentialSignerProgramId
);
const account = await connection.getAccountInfo(programStatePda);
const credential = new PublicKey(account!.data.slice(8 + 32, 8 + 64));
const schema = new PublicKey(account!.data.slice(8 + 64, 8 + 96));
 
// 2. Derive the wallet's attestation PDA
const [attestationPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from('attestation'),
    credential.toBuffer(),     // credential PDA from program state
    schema.toBuffer(),         // schema PDA from program state
    userPublicKey.toBuffer(),  // the wallet (nonce seed)
  ],
  sasProgramId
);
 
// 3. A non-null account at attestationPda means the wallet is linked
const attestation = await connection.getAccountInfo(attestationPda);

interface AlienSolanaSsoClientConfig {
  ssoBaseUrl: string;
  providerAddress: string;
  pollingInterval?: number;
  credentialSignerProgramId?: string;
  sasProgramId?: string;
  sessionRegistryProgramId?: string;
  allowInsecureSsoBaseUrl?: boolean;
}

interface SolanaLinkResponse {
  deep_link: string;
  polling_code: string;
  expired_at: number;
}

interface SolanaPollResponse {
  status: 'pending' | 'authorized' | 'rejected' | 'expired';
  oracle_signature?: string;   // hex-encoded
  oracle_public_key?: string;  // hex-encoded
  solana_address?: string;
  timestamp?: number;
  session_address?: string;
}

interface BuildAttestationParams {
  connection: Connection;
  payerPublicKey: PublicKey;
  sessionAddress: string;
  oracleSignature: Uint8Array;
  oraclePublicKey: PublicKey;
  timestamp: number;
  expiry: number; // pass 0 — currently unused
}

try {
  const { deep_link, polling_code } = await client.generateDeeplink(solanaAddress);
} catch (error) {
  console.error('Failed to generate deep link:', error);
}
 
try {
  const transaction = await client.buildCreateAttestationTransaction({
    connection,
    payerPublicKey: wallet.publicKey,
    sessionAddress: pollResponse.session_address!,
    oracleSignature: Uint8Array.from(Buffer.from(pollResponse.oracle_signature!, 'hex')),
    oraclePublicKey: new PublicKey(Buffer.from(pollResponse.oracle_public_key!, 'hex')),
    timestamp: pollResponse.timestamp!,
    expiry: 0,
  });
} catch (error) {
  console.error('Transaction building failed:', error);
}

import { AlienSolanaSsoClient } from '@alien-id/sso-solana';
import { Connection, PublicKey } from '@solana/web3.js';
import { Buffer } from 'buffer';
 
const client = new AlienSolanaSsoClient({
  ssoBaseUrl: 'https://sso.alien-api.com',
  providerAddress: 'platform-provider-address',
});
 
const connection = new Connection('https://api.mainnet-beta.solana.com');
 
async function linkWallet(wallet: any) {
  const solanaAddress = wallet.publicKey.toBase58();
 
  // Check whether the wallet already has a linking attestation
  // (existence of a link — not proof the current user controls the wallet)
  const existingSession = await client.getAttestation(solanaAddress);
  if (existingSession) {
    console.log('Wallet already linked:', existingSession);
    return;
  }
 
  // Generate deep link
  const { deep_link, polling_code } = await client.generateDeeplink(solanaAddress);
  displayQRCode(deep_link);
 
  // Poll for authorization
  const pollInterval = setInterval(async () => {
    const response = await client.pollAuth(polling_code);
 
    if (response.status === 'authorized') {
      clearInterval(pollInterval);
 
      // Build attestation transaction (submit within 5 minutes of the
      // oracle-signed timestamp, or it reverts with TimestampTooOld)
      const transaction = await client.buildCreateAttestationTransaction({
        connection,
        payerPublicKey: wallet.publicKey,
        sessionAddress: response.session_address!,
        oracleSignature: Uint8Array.from(Buffer.from(response.oracle_signature!, 'hex')),
        oraclePublicKey: new PublicKey(Buffer.from(response.oracle_public_key!, 'hex')),
        timestamp: response.timestamp!,
        expiry: 0,
      });
 
      // Set the blockhash and fee payer, then sign and send
      const { blockhash } = await connection.getLatestBlockhash();
      transaction.recentBlockhash = blockhash;
      transaction.feePayer = wallet.publicKey;
      const signedTransaction = await wallet.signTransaction(transaction);
      const signature = await connection.sendRawTransaction(
        signedTransaction.serialize()
      );
      await connection.confirmTransaction(signature);
 
      console.log('Attestation created! Signature:', signature);
 
      // Confirm the link is now visible
      const sessionAddress = await client.getAttestation(solanaAddress);
      console.log('Linked session:', sessionAddress);
 
      hideQRCode();
    } else if (response.status === 'rejected' || response.status === 'expired') {
      clearInterval(pollInterval);
      console.error('Attestation flow failed:', response.status);
      hideQRCode();
    }
  }, 5000);
}