pyth-client 0.5.0

pyth price oracle data structures and example usage
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
114
115
116
117
118

//! Program instructions for end-to-end testing and instruction counts

use bytemuck::bytes_of;

use crate::{PriceStatus, Price};

use {
  crate::id,
  borsh::{BorshDeserialize, BorshSerialize},
  solana_program::instruction::Instruction,
  crate::PriceConf,
};

/// Instructions supported by the pyth-client program, used for testing and
/// instruction counts
#[derive(Clone, Debug, BorshSerialize, BorshDeserialize, PartialEq)]
pub enum PythClientInstruction {
  Divide {
    numerator: PriceConf,
    denominator: PriceConf,
  },
  Multiply {
    x: PriceConf,
    y: PriceConf,
  },
  Add {
    x: PriceConf,
    y: PriceConf,
  },
  ScaleToExponent {
    x: PriceConf,
    expo: i32,
  },
  Normalize {
    x: PriceConf,
  },
  /// Don't do anything for comparison
  ///
  /// No accounts required for this instruction
  Noop,

  PriceStatusCheck {
    // A Price serialized as a vector of bytes. This field is stored as a vector of bytes (instead of a Price)
    // so that we do not have to add Borsh serialization to all structs, which is expensive.
    price_account_data: Vec<u8>,  
    expected_price_status: PriceStatus
  }
}

pub fn divide(numerator: PriceConf, denominator: PriceConf) -> Instruction {
  Instruction {
    program_id: id(),
    accounts: vec![],
    data: PythClientInstruction::Divide { numerator, denominator }
      .try_to_vec()
      .unwrap(),
  }
}

pub fn multiply(x: PriceConf, y: PriceConf) -> Instruction {
  Instruction {
    program_id: id(),
    accounts: vec![],
    data: PythClientInstruction::Multiply { x, y }
      .try_to_vec()
      .unwrap(),
  }
}

pub fn add(x: PriceConf, y: PriceConf) -> Instruction {
  Instruction {
    program_id: id(),
    accounts: vec![],
    data: PythClientInstruction::Add { x, y }
      .try_to_vec()
      .unwrap(),
  }
}

pub fn scale_to_exponent(x: PriceConf, expo: i32) -> Instruction {
  Instruction {
    program_id: id(),
    accounts: vec![],
    data: PythClientInstruction::ScaleToExponent { x, expo }
      .try_to_vec()
      .unwrap(),
  }
}

pub fn normalize(x: PriceConf) -> Instruction {
  Instruction {
    program_id: id(),
    accounts: vec![],
    data: PythClientInstruction::Normalize { x }
      .try_to_vec()
      .unwrap(),
  }
}

/// Noop instruction for comparison purposes
pub fn noop() -> Instruction {
  Instruction {
    program_id: id(),
    accounts: vec![],
    data: PythClientInstruction::Noop.try_to_vec().unwrap(),
  }
}

// Returns ok if price account status matches given expected price status.
pub fn price_status_check(price: &Price, expected_price_status: PriceStatus) -> Instruction {
  Instruction {
    program_id: id(), 
    accounts: vec![],
    data: PythClientInstruction::PriceStatusCheck { price_account_data: bytes_of(price).to_vec(), expected_price_status }
      .try_to_vec()
      .unwrap(),
  }
}