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

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

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,
}

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(),
  }
}