Struct api_signature::Signature

pub struct Signature { /* private fields */ }

Signing Object This object is for creating a API key signature.

This this example a static nonce is used to generate a API signature. This is to confirm the signature is as expected. The example is also using the default signature configuration.

use std::sync::Arc;
use api_signature::Signature;
use base64;

let mut signing = Signature::default();
let nonce = 1616492376594usize;

let validated_sign = base64::decode("4/dpxb3iT4tp/ZCVEwSnEsLxx0bqyhLpdfOpc6fn7OR8+UClSV5n9E6aSS8MPtnRfp32bAb0nmbRn6H8ndwLUQ==").unwrap();

let cal_sign = signing
  .var("payload", "ordertype=limit&pair=XBTUSD&price=37500&type=buy&volume=1.25")
  .var("secret_key", "kQH5HW/8p1uGOVjbgWA7FunAmGO8lsSUXNsu3eow76sz84Q18fWxnyRzBHCd3pd5nE9qa99HAZtuZuj6F1huXg==")
  .var("url", "/0/private/AddOrder")
  .nonce(Arc::new(move || -> Vec<u8> {nonce.to_string().as_bytes().to_vec()}))
  .sign();

assert_eq!(validated_sign, cal_sign)

At the time of signing is might be usefull to locking the nonce. By locking the nonce you will prevent change in the next signing. This is usefull in the default signing configuration, and if the nonce is not predictable.

In this example the signature will only generate a base64 encoded value.

use std::sync::Arc;
use api_signature::Signature;
use api_signature::SignCal;
use base64;

let mut signing = Signature::default();

let cal_sign = signing
    .config(SignCal::Base64Encode(SignCal::VarString("nonce".to_string()).into()));
let nonce = cal_sign.nonce_lock();

let b64_nonce = base64::encode(nonce).into_bytes();


assert_eq!(b64_nonce, cal_sign.sign());

Note: Using nonce_lock will lock the nonce until the next signing, as soon as a signing has happened the lock will be removed! Also running the lock multiple times will force the signature generator to create new nonce values.

Implementations

impl Signature

pub fn new() -> Self

pub fn nonce(&mut self, o: Arc<dyn Fn() -> Vec<u8>>) -> &mut Self

pub fn nonce_lock(&mut self) -> Vec<u8>

pub fn nonce_unlock(&mut self) -> &mut Self

pub fn config(&mut self, config: SignCal) -> &mut Self

pub fn var<T: Into<Variable>>(&mut self, key: &str, value: T) -> &mut Self

pub fn compare<T: Into<Vec<u8>>>(
    &mut self,
    signature: T,
    nonce: Vec<u8>
) -> bool

pub fn sign(&mut self) -> Vec<u8>

Trait Implementations

impl Clone for Signature

fn clone(&self) -> Signature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Signature

fn default() -> Self

Returns the “default value” for a type.