Struct TransactionSigner

Source

pub struct TransactionSigner { /* private fields */ }

Expand description

Ed25519 signer for Bulk exchange transactions.

§Example

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

Implementations§

Source §

impl TransactionSigner

Source

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 44)

33async fn main() -> eyre::Result<()> {
34    tracing_subscriber::fmt()
35        .with_env_filter(
36            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
37        )
38        .init();
39
40    let args = Args::parse();
41
42    info!("Connecting to {} for execution", args.url);
43    let key = env::var("BULK_PRIVATE_KEY")?;
44    let signer = TransactionSigner::from_private_key(key.as_str())?;
45    let client = BulkHttpClient::new(&HttpConfig {
46        base_url: args.url,
47        signer: Some(signer.clone()),
48        ..Default::default()
49    }).unwrap();
50
51    let account = if false {
52        Pubkey::from_str("8oqBACkDvyJjBoiWNbZPXrnjZvFjzUjMThbi9oahAVvH")?
53    } else {
54        signer.public_key()
55    };
56    let nonce = 1776682154418;
57
58    let mut orders = vec![
59        Action::TakeProfit(StopOrTP {
60            symbol: Arc::from("BTC-USD"),
61            is_above: false,
62            size: 0.480894,
63            threshold: 40000.0,
64            limit: None,
65            meta: ActionMeta {
66                account,
67                nonce,
68                seqno: 0,
69                hash: None,
70            }
71        }),
72    ];
73
74    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
75    eprintln!("results: {:?}\n", results);
76
77    process::exit(0);
78}

More examples

Hide additional examples

examples/execute_limit.rs (line 41)

30async fn main() -> eyre::Result<()> {
31    tracing_subscriber::fmt()
32        .with_env_filter(
33            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
34        )
35        .init();
36
37    let args = Args::parse();
38
39    info!("Connecting to {} for execution", args.url);
40    let key = env::var("BULK_PRIVATE_KEY")?;
41    let signer = TransactionSigner::from_private_key(key.as_str())?;
42    let client = BulkHttpClient::new(&HttpConfig {
43        base_url: args.url,
44        signer: Some(signer.clone()),
45        ..Default::default()
46    }).unwrap();
47
48    let account = signer.public_key();
49    let nonce = make_nonce();
50
51    let mut orders = vec![
52        Action::LimitOrder(LimitOrder {
53            symbol: Arc::from("BTC-USD"),
54            is_buy: true,
55            price: 1000.0,
56            size: 0.0001,
57            tif: TimeInForce::IOC,
58            reduce_only: false,
59            iso: false,
60            meta: ActionMeta {
61                account,
62                nonce,
63                seqno: 0,
64                hash: None,
65            }
66        }),
67        Action::LimitOrder(LimitOrder {
68            symbol: Arc::from("ETH-USD"),
69            is_buy: true,
70            price: 1000.0,
71            size: 0.0001,
72            tif: TimeInForce::IOC,
73            reduce_only: false,
74            iso: false,
75            meta: ActionMeta {
76                account,
77                nonce,
78                seqno: 1,
79                hash: None,
80            }
81        }),
82    ];
83
84    let oids = orders.iter_mut()
85        .map(|o| o.hash().to_string())
86        .collect::<Vec<_>>();
87
88    eprintln!("order IDs: {:?}", oids);
89
90    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
91    eprintln!("results: {:?}\n", results);
92
93    process::exit(0);
94}

Source

pub fn sign_bytes(&self, message: &[u8]) -> 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.

Source

pub fn public_key(&self) -> Pubkey

Get pubkey

Examples found in repository ?

examples/execute_cond.rs (line 54)

33async fn main() -> eyre::Result<()> {
34    tracing_subscriber::fmt()
35        .with_env_filter(
36            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
37        )
38        .init();
39
40    let args = Args::parse();
41
42    info!("Connecting to {} for execution", args.url);
43    let key = env::var("BULK_PRIVATE_KEY")?;
44    let signer = TransactionSigner::from_private_key(key.as_str())?;
45    let client = BulkHttpClient::new(&HttpConfig {
46        base_url: args.url,
47        signer: Some(signer.clone()),
48        ..Default::default()
49    }).unwrap();
50
51    let account = if false {
52        Pubkey::from_str("8oqBACkDvyJjBoiWNbZPXrnjZvFjzUjMThbi9oahAVvH")?
53    } else {
54        signer.public_key()
55    };
56    let nonce = 1776682154418;
57
58    let mut orders = vec![
59        Action::TakeProfit(StopOrTP {
60            symbol: Arc::from("BTC-USD"),
61            is_above: false,
62            size: 0.480894,
63            threshold: 40000.0,
64            limit: None,
65            meta: ActionMeta {
66                account,
67                nonce,
68                seqno: 0,
69                hash: None,
70            }
71        }),
72    ];
73
74    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
75    eprintln!("results: {:?}\n", results);
76
77    process::exit(0);
78}

More examples

Hide additional examples

examples/execute_limit.rs (line 48)

30async fn main() -> eyre::Result<()> {
31    tracing_subscriber::fmt()
32        .with_env_filter(
33            EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into())
34        )
35        .init();
36
37    let args = Args::parse();
38
39    info!("Connecting to {} for execution", args.url);
40    let key = env::var("BULK_PRIVATE_KEY")?;
41    let signer = TransactionSigner::from_private_key(key.as_str())?;
42    let client = BulkHttpClient::new(&HttpConfig {
43        base_url: args.url,
44        signer: Some(signer.clone()),
45        ..Default::default()
46    }).unwrap();
47
48    let account = signer.public_key();
49    let nonce = make_nonce();
50
51    let mut orders = vec![
52        Action::LimitOrder(LimitOrder {
53            symbol: Arc::from("BTC-USD"),
54            is_buy: true,
55            price: 1000.0,
56            size: 0.0001,
57            tif: TimeInForce::IOC,
58            reduce_only: false,
59            iso: false,
60            meta: ActionMeta {
61                account,
62                nonce,
63                seqno: 0,
64                hash: None,
65            }
66        }),
67        Action::LimitOrder(LimitOrder {
68            symbol: Arc::from("ETH-USD"),
69            is_buy: true,
70            price: 1000.0,
71            size: 0.0001,
72            tif: TimeInForce::IOC,
73            reduce_only: false,
74            iso: false,
75            meta: ActionMeta {
76                account,
77                nonce,
78                seqno: 1,
79                hash: None,
80            }
81        }),
82    ];
83
84    let oids = orders.iter_mut()
85        .map(|o| o.hash().to_string())
86        .collect::<Vec<_>>();
87
88    eprintln!("order IDs: {:?}", oids);
89
90    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
91    eprintln!("results: {:?}\n", results);
92
93    process::exit(0);
94}