equanetwork-cli 0.0.4

The Equa Network command line interface
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

//! Shared helpers for building Equa Network instruction transactions.

use anyhow::{anyhow, Result};
use equanetwork::{get_network_address, get_vault_address};
use solana_address::Address;
use solana_client::rpc_client::RpcClient;
use solana_instruction::Instruction;
use solana_pubkey::Pubkey;
use solana_signer::Signer;
use spl_associated_token_account_interface::{
    address::get_associated_token_address, instruction::create_associated_token_account_idempotent,
};

pub fn pk(address: Address) -> Pubkey {
    Pubkey::new_from_array(address.to_bytes())
}

pub fn addr(pubkey: Pubkey) -> Address {
    Address::new_from_array(pubkey.to_bytes())
}

pub fn account_exists(rpc: &RpcClient, account: &Pubkey) -> bool {
    rpc.get_account(account).is_ok()
}

pub fn ensure_ata(
    rpc: &RpcClient,
    ixs: &mut Vec<Instruction>,
    payer: &impl Signer,
    owner: &Pubkey,
    mint: &Pubkey,
) -> Pubkey {
    let ata = get_associated_token_address(owner, mint);
    if !account_exists(rpc, &ata) {
        ixs.push(create_associated_token_account_idempotent(
            &payer.pubkey(),
            owner,
            mint,
            &spl_token_interface::ID,
        ));
    }
    ata
}

pub fn require_signer(config: &crate::config::Config) -> Result<solana_keypair::Keypair> {
    config
        .keypair()
        .ok_or_else(|| anyhow!("signer required (set --signer or Solana CLI config keypair)"))
}

/// Parse a `u32` network id from decimal or hex (`0x…` / bare hex).
pub fn parse_network_id(raw: &str) -> Result<u32> {
    let trimmed = raw.trim();
    if let Some(hex) = trimmed
        .strip_prefix("0x")
        .or_else(|| trimmed.strip_prefix("0X"))
    {
        return u32::from_str_radix(hex, 16).map_err(|e| anyhow!("invalid network-id hex: {e}"));
    }
    if trimmed.chars().all(|c| c.is_ascii_hexdigit())
        && trimmed.chars().any(|c| matches!(c, 'a'..='f' | 'A'..='F'))
        && !trimmed.chars().all(|c| c.is_ascii_digit())
    {
        return u32::from_str_radix(trimmed, 16)
            .map_err(|e| anyhow!("invalid network-id hex: {e}"));
    }
    trimmed
        .parse::<u32>()
        .map_err(|e| anyhow!("network-id must be a u32 decimal or hex: {e}"))
}

pub fn network_pda(network_id: u32) -> Address {
    get_network_address(network_id).0
}

pub fn vault_pda(network: &Pubkey, mint: &Pubkey) -> Address {
    get_vault_address(&addr(*network), &addr(*mint)).0
}