Struct TransactionSigner 

pub struct TransactionSigner { /* private fields */ }

Ed25519 signer for Bulk exchange transactions.

Example

let signer = TransactionSigner::from_private_key("base58_key")?;
let mut tx = Transaction { .. };
tx.sign(&signer)?;

Implementations

impl TransactionSigner

pub fn from_private_key(key_b58: &str) -> Result<Self>

Create a signer from a base58-encoded private key (32-byte seed).

Arguments

• private_key: 32 or 64 byte private key

Examples found in repository

examples/execute_cond.rs (line 41)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
        )
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    }).unwrap();

    let account = if false {
        Pubkey::from_str("8oqBACkDvyJjBoiWNbZPXrnjZvFjzUjMThbi9oahAVvH")?
    } else {
        signer.public_key()
    };
    let nonce = 1776682154418;

    let orders = vec![
        Action::TakeProfit(StopOrTP {
            symbol: Arc::from("BTC-USD"),
            is_above: false,
            size: 0.480894,
            threshold: 40000.0,
            limit: None,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 0,
                hash: None,
            }
        }),
    ];

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

examples/execute_limit.rs (line 41)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
        )
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    }).unwrap();

    let account = signer.public_key();
    let nonce = make_nonce();

    let mut orders = vec![
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("BTC-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 0,
                hash: None,
            }
        }),
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("ETH-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 1,
                hash: None,
            }
        }),
    ];

    let oids = orders.iter_mut()
        .map(|o| o.hash().to_string())
        .collect::<Vec<_>>();

    eprintln!("order IDs: {:?}", oids);

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

pub fn sign_bytes(&self, message: &[u8]) -> Result<Signature>

Sign an arbitrary byte slice and return the raw 64-byte signature.

Used by [BulkHttpClient] for generic (non-Signable) payloads such as leverage updates, agent wallet management, and faucet requests, where the exchange expects a signature over the canonical JSON string.

pub fn sign_transaction_bytes(&self, message: &[u8]) -> Result<Signature>

pub fn sign_transaction_clear(&self, clear_text: &str) -> Result<Signature>

pub fn tx_signature_mode(&self) -> TxSignatureMode

pub fn tx_signature_mode_hint_header_value(&self) -> Option<&'static str>

pub fn public_key(&self) -> Pubkey

Get pubkey

Examples found in repository

examples/execute_cond.rs (line 51)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
        )
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    }).unwrap();

    let account = if false {
        Pubkey::from_str("8oqBACkDvyJjBoiWNbZPXrnjZvFjzUjMThbi9oahAVvH")?
    } else {
        signer.public_key()
    };
    let nonce = 1776682154418;

    let orders = vec![
        Action::TakeProfit(StopOrTP {
            symbol: Arc::from("BTC-USD"),
            is_above: false,
            size: 0.480894,
            threshold: 40000.0,
            limit: None,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 0,
                hash: None,
            }
        }),
    ];

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

examples/execute_limit.rs (line 48)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
        )
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    }).unwrap();

    let account = signer.public_key();
    let nonce = make_nonce();

    let mut orders = vec![
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("BTC-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 0,
                hash: None,
            }
        }),
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("ETH-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 1,
                hash: None,
            }
        }),
    ];

    let oids = orders.iter_mut()
        .map(|o| o.hash().to_string())
        .collect::<Vec<_>>();

    eprintln!("order IDs: {:?}", oids);

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

pub fn public_key_b58(&self) -> String

Get pubkey as b58 encoding

Trait Implementations

impl Clone for TransactionSigner

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TransactionSigner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.