lighter-sdk 0.1.1

Rust SDK for interacting with the Lighter exchange over REST, WebSocket, and signer-backed transaction flows.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};

use libloading::Library;

use crate::error::{Result, SdkError};

static SIGNER_LIBRARY: OnceLock<SignerLibrary> = OnceLock::new();
static INIT_LOCK: Mutex<()> = Mutex::new(());

pub struct SignerLibrary {
    #[allow(dead_code)]
    library: Library,
}

unsafe impl Send for SignerLibrary {}
unsafe impl Sync for SignerLibrary {}

impl SignerLibrary {
    pub fn lib(&self) -> &Library {
        &self.library
    }
}

fn lib_filename() -> &'static str {
    if cfg!(target_os = "macos") && cfg!(target_arch = "aarch64") {
        "lighter-signer-darwin-arm64.dylib"
    } else if cfg!(target_os = "linux") && cfg!(target_arch = "x86_64") {
        "lighter-signer-linux-amd64.so"
    } else if cfg!(target_os = "linux") && cfg!(target_arch = "aarch64") {
        "lighter-signer-linux-arm64.so"
    } else if cfg!(target_os = "windows") && cfg!(target_arch = "x86_64") {
        "lighter-signer-windows-amd64.dll"
    } else {
        panic!(
            "Unsupported platform/architecture: {}/{}",
            std::env::consts::OS,
            std::env::consts::ARCH
        );
    }
}

fn push_path(paths: &mut Vec<PathBuf>, configured: &Path, filename: &str) {
    if configured.is_dir() {
        paths.push(configured.join(filename));
    } else {
        paths.push(configured.to_path_buf());
    }
}

fn search_paths(configured_path: Option<&str>) -> Vec<PathBuf> {
    let filename = lib_filename();
    let mut paths = Vec::new();

    // 1. Configured path
    if let Some(p) = configured_path {
        push_path(&mut paths, Path::new(p), filename);
    }

    // 2. LIGHTER_SIGNER_LIB_PATH env var
    if let Ok(env_path) = std::env::var("LIGHTER_SIGNER_LIB_PATH") {
        push_path(&mut paths, Path::new(&env_path), filename);
    }

    // 3. Next to the current executable
    if let Ok(exe) = std::env::current_exe()
        && let Some(dir) = exe.parent()
    {
        paths.push(dir.join(filename));
        paths.push(dir.join("signers").join(filename));
    }

    // 4. Current directory
    paths.push(PathBuf::from(filename));
    paths.push(PathBuf::from("signers").join(filename));

    paths
}

pub fn load_signer(configured_path: Option<&str>) -> Result<&'static SignerLibrary> {
    if let Some(lib) = SIGNER_LIBRARY.get() {
        return Ok(lib);
    }

    let _guard = INIT_LOCK.lock().unwrap_or_else(|e| e.into_inner());

    if let Some(lib) = SIGNER_LIBRARY.get() {
        return Ok(lib);
    }

    let paths = search_paths(configured_path);
    let mut errors = Vec::new();

    for path in &paths {
        match unsafe { Library::new(path) } {
            Ok(library) => {
                tracing::info!("Loaded signer library from {}", path.display());
                let _ = SIGNER_LIBRARY.set(SignerLibrary { library });
                return SIGNER_LIBRARY.get().ok_or(SdkError::SignerNotLoaded);
            }
            Err(e) => {
                errors.push(format!("{}: {}", path.display(), e));
                tracing::debug!("Failed to load signer from {}: {}", path.display(), e);
            }
        }
    }

    Err(SdkError::SignerLoadFailed(errors.join(" | ")))
}

pub fn get_signer() -> Result<&'static SignerLibrary> {
    SIGNER_LIBRARY.get().ok_or(SdkError::SignerNotLoaded)
}