Referral Code Setup

How Referral Codes Work

Kamino’s referral system allows referrers to earn commission from the borrowing activity of referred users. Each referrer creates a unique referral code that can be shared publicly without revealing a wallet address, providing a user-friendly way to distribute referral codes.

In the SDK, the shortUrl field represents the referral code.

TypeScript
Rust

Import Dependencies

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  assertIsTransactionWithinSizeLimit,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
} from '@solana/kit';
import {
  PROGRAM_ID,
  getInitReferrerStateAndShortUrlIxs,
  getReferrerForShortUrl,
  isShortUrlAvailable,
} from '@kamino-finance/klend-sdk';
import { parseKeypairFile } from '@kamino-finance/klend-sdk/dist/utils/signer.js';

Initialize RPC

const KEYPAIR_FILE = '/path/to/your/keypair.json';
const signer = await parseKeypairFile(KEYPAIR_FILE);

const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
const rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.mainnet-beta.solana.com');

Create Referrer State with Short URL

Check the referral code is free, then create the referrer state and short URL.

const shortUrl = 'your-referral-code';

if (!(await isShortUrlAvailable(rpc, shortUrl, PROGRAM_ID))) {
  console.log('Referral code is invalid or already taken:', shortUrl);
}

const initReferrerIx = await getInitReferrerStateAndShortUrlIxs({
  referrer: signer,
  shortUrl,
  programId: PROGRAM_ID,
});

The short URL must be unique, at most 32 characters, and use only ASCII letters, digits, underscore and hyphen. isShortUrlAvailable checks both. Each wallet gets one code.

Build the Transaction

const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();

const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayerSigner(signer, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
  (tx) => appendTransactionMessageInstructions([initReferrerIx], tx)
);

Sign and Send

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
assertIsTransactionWithinSizeLimit(signedTransaction);

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedTransaction, {
  commitment: 'confirmed',
  skipPreflight: true,
});

console.log('Referrer registered! Signature:', getSignatureFromTransaction(signedTransaction));

Verify Short URL Resolution

const referrer = await getReferrerForShortUrl(rpc, shortUrl, PROGRAM_ID);
console.log(`Code ${shortUrl} resolves to:`, referrer);

Referrer setup complete. The short URL is active and can be shared with users to establish referral relationships.

Add Dependencies

[dependencies]
klend-interface = "0.6.0"
solana-pubkey = "2.1"
solana-instruction = "2.1"
solana-sdk = "~2.3"
solana-client = "~2.3"
spl-token = "7"
spl-associated-token-account = "6"

klend-interface is a lightweight Rust instruction builder that creates Vec<Instruction> with required refresh instructions prepended automatically.

Set Up RPC Client

use solana_client::rpc_client::RpcClient;
use solana_sdk::signer::keypair::read_keypair_file;
use solana_sdk::signer::Signer;

let rpc_client = RpcClient::new("https://api.mainnet-beta.solana.com");
let signer = read_keypair_file("/path/to/your/keypair.json")
    .expect("Failed to read keypair file");
let owner = signer.pubkey();

Derive PDAs and Build Instruction

use klend_interface::instructions::referrer::{
    init_referrer_state_and_short_url,
    InitReferrerStateAndShortUrlAccounts,
};
use klend_interface::pda;
use klend_interface::KLEND_PROGRAM_ID;
use solana_pubkey::Pubkey;

let referrer = signer.pubkey();
let short_url = format!("ref-{}", std::time::SystemTime::now()
    .duration_since(std::time::UNIX_EPOCH).unwrap().as_secs());

// Derive required PDAs
let (referrer_state, _) = pda::referrer_state(&KLEND_PROGRAM_ID, &referrer);
let (referrer_short_url, _) = pda::short_url(&KLEND_PROGRAM_ID, &short_url);
let (referrer_user_metadata, _) = pda::user_metadata(&KLEND_PROGRAM_ID, &referrer);

let ix = init_referrer_state_and_short_url(
    InitReferrerStateAndShortUrlAccounts {
        referrer,
        referrer_state,
        referrer_short_url,
        referrer_user_metadata,
    },
    short_url.clone(),
);

The short URL must be unique, contain a maximum of 32 characters, and use only ASCII alphanumeric characters plus underscore and hyphen.

Send Transaction

use solana_sdk::transaction::Transaction;
use solana_sdk::message::Message;

let message = Message::new(&[ix], Some(&referrer));
let recent_blockhash = rpc_client.get_latest_blockhash()?;
let tx = Transaction::new(&[&signer], message, recent_blockhash);
let signature = rpc_client.send_and_confirm_transaction(&tx)?;
println!("Referrer setup successful! Short URL: {short_url}");
println!("Signature: {signature}");

Developers

Earn

Borrow

Multiply

Liquidity

Portfolio

Rewards

Oracle

Agentic Finance

Resources

How Referral Codes Work

Import Dependencies

Initialize RPC

Create Referrer State with Short URL

Build the Transaction

Sign and Send

Verify Short URL Resolution

Add Dependencies

Set Up RPC Client

Derive PDAs and Build Instruction

Send Transaction

​How Referral Codes Work

​Import Dependencies

​Initialize RPC

​Create Referrer State with Short URL

​Build the Transaction

​Sign and Send

​Verify Short URL Resolution

​Add Dependencies

​Set Up RPC Client

​Derive PDAs and Build Instruction

​Send Transaction

How Referral Codes Work

Import Dependencies

Initialize RPC

Create Referrer State with Short URL

Build the Transaction

Sign and Send

Verify Short URL Resolution

Add Dependencies

Set Up RPC Client

Derive PDAs and Build Instruction

Send Transaction