SPL Name Service IDL

SPL Name Service provides on-chain domain name resolution on Solana (e.g., .sol domains via Bonfida). Maps human-readable names to Solana addresses, Twitter handles, and other records.

spl
v0.2.0
Core / Standard

Program address

namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX

Download IDL spl website

Instructions: 4
Accounts: 1
Events: 0
Types: 0

What the program exposes

Instructions 4

create
update
transfer
delete

Accounts 1

NameRecordHeader

Use it in your code

Load the SPL Name Service IDL with Anchor in TypeScript, Rust or Python.

import { Connection, PublicKey } from "@solana/web3.js";
import { Program, AnchorProvider, Idl } from "@coral-xyz/anchor";

// Load the SPL Name Service IDL
import idl from "./spl name service.json";

const PROGRAM_ID = new PublicKey("namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX");

// Set up the provider and program
const connection = new Connection("https://api.mainnet-beta.solana.com");
const provider = new AnchorProvider(connection, wallet, {
  commitment: "confirmed",
});
const program = new Program(idl as Idl, provider);

// Fetch and decode an account
const accountData = await program.account.sPL_Name_Service
  .fetch(accountPublicKey);
console.log("Account data:", accountData);

// Build and send an instruction
const tx = await program.methods
  .initialize(/* ...args */)
  .accounts({
    /* ...required accounts */
  })
  .rpc();
console.log("Transaction signature:", tx);

use anchor_client::solana_sdk::pubkey::Pubkey;
use anchor_client::solana_sdk::signature::Keypair;
use anchor_client::{Client, Cluster};
use std::str::FromStr;

// SPL Name Service program ID
const PROGRAM_ID: &str = "namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX";

fn main() -> anyhow::Result<()> {
    let payer = Keypair::new();
    let client = Client::new(Cluster::Mainnet, &payer);
    let program_id = Pubkey::from_str(PROGRAM_ID)?;
    let program = client.program(program_id)?;

    // Fetch and deserialize an account
    let account: SPL_Name_ServiceAccount = program.account(account_pubkey)?;
    println!("Account data: {:?}", account);

    // Build and send a transaction
    let tx = program
        .request()
        .accounts(s_p_l__name__service::accounts::Initialize {
            // ...required accounts
        })
        .args(s_p_l__name__service::instruction::Initialize {
            // ...instruction args
        })
        .send()?;
    println!("Transaction signature: {}", tx);

    Ok(())
}

from solana.rpc.api import Client
from solders.pubkey import Pubkey
from anchorpy import Program, Provider, Wallet
import json

# Load the SPL Name Service IDL
with open("spl name service.json") as f:
    idl_data = json.load(f)

PROGRAM_ID = Pubkey.from_string("namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX")

# Set up the provider and program
client = Client("https://api.mainnet-beta.solana.com")
provider = Provider(client, Wallet.local())
program = Program(idl_data, PROGRAM_ID, provider)

# Fetch and decode an account
account = await program.account["SPL_Name_Service"].fetch(account_pubkey)
print(f"Account data: {account}")

# Build and send an instruction
tx = await program.rpc["initialize"](
    # ...instruction args
    ctx=program.context(
        accounts={
            # ...required accounts
        }
    )
)
print(f"Transaction signature: {tx}")

The JSON

The first 30 lines of spl name service.json.

spl name service.json

{
  "version": "0.2.0",
  "name": "spl_name_service",
  "instructions": [
    {
      "name": "create",
      "accounts": [
        {
          "name": "systemProgram",
          "isMut": false,
          "isSigner": false
        },
        {
          "name": "payer",
          "isMut": true,
          "isSigner": true
        },
        {
          "name": "nameAccount",
          "isMut": true,
          "isSigner": false
        },
        {
          "name": "nameOwner",
          "isMut": false,
          "isSigner": false
        }
      ],
      "args": [
        {
...

Frequently asked questions

What is the SPL Name Service IDL?

The SPL Name Service IDL (Interface Definition Language) is a JSON schema that describes the on-chain program interface for the SPL Name Service smart contract on Solana. It defines all available instructions, account structures, events, and types needed to interact with the program. This one has 4 instructions, 1 account types, 0 events and 0 type definitions.

How do I use the SPL Name Service IDL in my project?

You can use the SPL Name Service IDL with Anchor framework clients in TypeScript (@coral-xyz/anchor), Rust (anchor-client), or Python (anchorpy). Download the JSON file, import it in your project, and use it to create a Program instance that can call instructions and decode accounts.

What is the SPL Name Service program address on Solana?

The SPL Name Service program is deployed at address namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX on Solana mainnet.

What version of the SPL Name Service IDL is this?

This is version 0.2.0 of the SPL Name Service IDL. IDL versions follow program deployments and change as the protocol evolves, so check it against the program on-chain before you integrate.

Build on SPL Name Service with AllenHark

Stream the program's accounts and transactions with Yellowstone gRPC, read its state over Solana RPC, or see its transactions before the block is built with ShredStream. To trade against it, try the trading bots or the PumpFun sniper.

Browse all Solana IDLs