SPL Shared Memory IDL

SPL Shared Memory program enables cross-program data sharing through shared memory regions on Solana. Allows programs to communicate large data payloads efficiently. (Deprecated)

spl
v2.0.6
Core / Standard

Program address

shmem4EWT2sPdVGvTZCzXXRAURL9G5vpPxNwSeKhHUL

Download IDL spl website

Instructions: 0
Accounts: 0
Events: 0
Types: 0

Use it in your code

Load the SPL Shared Memory 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 Shared Memory IDL
import idl from "./spl shared memory.json";

const PROGRAM_ID = new PublicKey("shmem4EWT2sPdVGvTZCzXXRAURL9G5vpPxNwSeKhHUL");

// 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_Shared_Memory
  .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 Shared Memory program ID
const PROGRAM_ID: &str = "shmem4EWT2sPdVGvTZCzXXRAURL9G5vpPxNwSeKhHUL";

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_Shared_MemoryAccount = program.account(account_pubkey)?;
    println!("Account data: {:?}", account);

    // Build and send a transaction
    let tx = program
        .request()
        .accounts(s_p_l__shared__memory::accounts::Initialize {
            // ...required accounts
        })
        .args(s_p_l__shared__memory::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 Shared Memory IDL
with open("spl shared memory.json") as f:
    idl_data = json.load(f)

PROGRAM_ID = Pubkey.from_string("shmem4EWT2sPdVGvTZCzXXRAURL9G5vpPxNwSeKhHUL")

# 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_Shared_Memory"].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 shared memory.json.

spl shared memory.json

{
  "version": "2.0.6",
  "name": "spl_shared_memory",
  "instructions": [],
  "metadata": {
    "instruction_selector_type": "single-instruction"
  }
}
...

Frequently asked questions

What is the SPL Shared Memory IDL?

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

How do I use the SPL Shared Memory IDL in my project?

You can use the SPL Shared Memory 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 Shared Memory program address on Solana?

The SPL Shared Memory program is deployed at address shmem4EWT2sPdVGvTZCzXXRAURL9G5vpPxNwSeKhHUL on Solana mainnet.

What version of the SPL Shared Memory IDL is this?

This is version 2.0.6 of the SPL Shared Memory 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 Shared Memory 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

Use it in your code

The JSON

Frequently asked questions

Related IDLs

Build on SPL Shared Memory with AllenHark