blockworks-foundation
/
sbv2-solana
mirror of https://github.com/blockworks-foundation/sbv2-solana.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

updated basic-oracle function example

This commit is contained in:
Conner Gallagher 2023-06-20 09:33:23 -06:00
parent 9922f398b0
commit d2c5212b13
19 changed files with 175957 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/functions/01_basic_oracle/Anchor.toml
View File

@ -16,7 +16,7 @@ wallet = "~/.config/solana/id.json"
test = "pnpm exec ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"
[test.validator]
url = "https://api.devnet.solana.com"
url = "https://switchbo-switchbo-6225.devnet.rpcpool.com/f6fb9f02-0777-498b-b8f5-67cbb1fc0d14"
[test]
startup_wait = 15000

4
examples/functions/01_basic_oracle/Cargo.lock generated
View File

@ -3938,7 +3938,9 @@ dependencies = [
[[package]]
name = "switchboard-solana"
version = "0.5.2"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "479a634d1ceb41224c020c25c07febf68c3a8c65d688d6c487ebc754d893dc18"
dependencies = [
"anchor-client",
"anchor-lang",

4
examples/functions/01_basic_oracle/Cargo.toml
View File

@ -18,5 +18,5 @@ default = []
[dependencies]
# anchor-lang = "0.28.0"
# switchboard-solana = "0.5.2"
switchboard-solana = { version = "0.5.2", path = "../../../rust/switchboard-solana" }
switchboard-solana = "0.5.3"
# switchboard-solana = { path = "../../../rust/switchboard-solana" }

175556
examples/functions/01_basic_oracle/binance.exchangeInfo.json Normal file
View File

File diff suppressed because it is too large Load Diff

33
examples/functions/01_basic_oracle/scripts/devnet.ts Normal file
View File

@ -0,0 +1,33 @@
#!/usr/bin/env tsx
import * as anchor from "@coral-xyz/anchor";
import { BasicOracle } from "../target/types/basic_oracle";
async function main() {
const program = anchor.workspace.BasicOracle as anchor.Program<BasicOracle>;
}
main().catch((err) => {
console.error(err);
process.exit(1);
});
const getStringArg = (arg: string): string => {
const args = process.argv.slice(2);
const argIdx = args.findIndex((v) => v === arg || v === `--${arg}`);
if (argIdx === -1) {
return "";
}
if (argIdx + 1 > args.length) {
throw new Error(`Failed to find arg`);
}
return args[argIdx + 1];
};
const getFlag = (arg: string): boolean => {
const args = process.argv.slice(2);
const argIdx = args.findIndex((v) => v === arg || v === `--${arg}`);
if (argIdx === -1) {
return false;
}
return true;
};

7
examples/functions/01_basic_oracle/sgx-function/Cargo.toml
View File

@ -8,10 +8,11 @@ name = "basic-oracle-function"
path = "src/main.rs"
[dependencies]
basic_oracle = { path = "../", features = ["no-entrypoint"] }
tokio = "^1"
futures = "0.3"
switchboard-solana = "0.5.2"
switchboard-utils = "0.5.0"
basic_oracle = { path = "../", features = ["no-entrypoint"] }
serde = "^1"
serde_json = "^1"
switchboard-utils = "0.5.0"
switchboard-solana = "0.5.3"
# switchboard-solana = { path = "../../../../rust/switchboard-solana" }

173
examples/functions/01_basic_oracle/sgx-function/src/binance.rs
View File

@ -6,6 +6,8 @@ pub use switchboard_utils::reqwest;
use serde::Deserialize;
const ONE: i128 = 1000000000;
#[allow(non_snake_case)]
#[derive(Deserialize, Default, Clone, Debug)]
pub struct Ticker {
@ -23,7 +25,13 @@ pub struct Ticker {
pub closeTime: u64, // ms
}
impl Into<OracleData> for Ticker {
#[derive(Clone, Debug)]
pub struct IndexData {
pub symbol: String,
pub hr: Ticker,
pub d: Ticker,
}
impl Into<OracleData> for IndexData {
fn into(self) -> OracleData {
let oracle_timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
@ -31,51 +39,39 @@ impl Into<OracleData> for Ticker {
.as_secs()
.try_into()
.unwrap_or_default();
let price = parse_string_value(self.lastPrice.as_str());
let volume = parse_string_value(self.volume.as_str());
let twap_24hr = parse_string_value(self.weightedAvgPrice.as_str());
let price = parse_string_value(self.hr.lastPrice.as_str());
let volume_1hr = parse_string_value(self.hr.volume.as_str());
let volume_24hr = parse_string_value(self.d.volume.as_str());
let twap_1hr = parse_string_value(self.hr.weightedAvgPrice.as_str());
let twap_24hr = parse_string_value(self.d.weightedAvgPrice.as_str());
OracleData {
oracle_timestamp,
price,
volume,
volume_1hr,
volume_24hr,
twap_1hr,
twap_24hr,
}
}
}
// impl TryInto<OracleData> for Ticker {
// type Error = SwitchboardClientError;
// fn try_into(self) -> std::result::Result<OracleData, SwitchboardClientError> {
// let oracle_timestamp = std::time::SystemTime::now()
// .duration_since(std::time::UNIX_EPOCH)
// .unwrap_or_default()
// .as_secs()
// .try_into()
// .unwrap_or_default();
// let price = parse_string_value(self.lastPrice.as_str());
// let volume = parse_string_value(self.volume.as_str());
// let twap_24hr = parse_string_value(self.weightedAvgPrice.as_str());
// Ok(OracleData {
// oracle_timestamp,
// price,
// volume,
// twap_24hr,
// })
// }
// }
#[derive(Clone, Debug)]
pub struct BinanceTickers {
pub btc: Option<OracleData>,
pub eth: Option<OracleData>,
pub struct Binance {
btc_usdt: IndexData,
eth_usdt: IndexData,
sol_usdt: IndexData,
usdc_usdt: IndexData,
}
impl BinanceTickers {
pub async fn fetch() -> std::result::Result<Self, SwitchboardClientError> {
let symbols = ["BTCUSDT", "ETHUSDT", "SOLUSDC"];
let tickers = reqwest::get(format!(
impl Binance {
// Fetch data from the Binance API
pub async fn fetch() -> std::result::Result<Binance, SwitchboardClientError> {
let symbols = ["BTCUSDT", "ETHUSDT", "SOLUSDT", "USDCUSDT"];
let tickers_1hr = reqwest::get(format!(
"https://api.binance.com/api/v3/ticker?symbols=[{}]&windowSize=1h",
symbols
.iter()
@ -89,16 +85,113 @@ impl BinanceTickers {
.await
.unwrap();
let btc_ticker = tickers.get(0).unwrap().clone();
let eth_ticker = tickers.get(1).unwrap().clone();
let tickers_1d = reqwest::get(format!(
"https://api.binance.com/api/v3/ticker?symbols=[{}]&windowSize=1d",
symbols
.iter()
.map(|x| format!("\"{}\"", x))
.collect::<Vec<String>>()
.join(",")
))
.await
.unwrap()
.json::<Vec<Ticker>>()
.await
.unwrap();
Ok(BinanceTickers {
btc: Some(btc_ticker.into()),
eth: Some(eth_ticker.into()),
assert!(
tickers_1d.len() == symbols.len(),
"ticker (1d) length mismatch"
);
assert!(
tickers_1hr.len() == symbols.len(),
"ticker (1hr) length mismatch"
);
let data: Vec<IndexData> = symbols
.iter()
.enumerate()
.map(|(i, s)| IndexData {
symbol: s.to_string(),
d: tickers_1d.get(i).unwrap().clone(),
hr: tickers_1hr.get(i).unwrap().clone(),
})
.collect();
Ok(Binance {
btc_usdt: data.get(0).unwrap().clone(),
eth_usdt: data.get(1).unwrap().clone(),
sol_usdt: data.get(2).unwrap().clone(),
usdc_usdt: data.get(3).unwrap().clone(),
})
}
pub fn to_ixns(&self, runner: &FunctionRunner) -> Vec<Instruction> {
let btc_usdt: OracleData = self.btc_usdt.clone().into();
// let btc_usdc: OracleData = self.btc_usdc.clone().into();
let eth_usdt: OracleData = self.eth_usdt.clone().into();
let sol_usdt: OracleData = self.sol_usdt.clone().into();
let usdc_usdt: OracleData = self.usdc_usdt.clone().into();
let usdt_usdc: OracleData = OracleData {
oracle_timestamp: usdc_usdt.oracle_timestamp,
price: ONE.checked_div(usdc_usdt.price).unwrap(),
volume_1hr: usdc_usdt.volume_1hr,
volume_24hr: usdc_usdt.volume_24hr,
twap_1hr: ONE.checked_div(usdc_usdt.twap_1hr).unwrap(),
twap_24hr: ONE.checked_div(usdc_usdt.twap_24hr).unwrap(),
};
let params = RefreshPricesParams {
btc: Some(btc_usdt),
eth: Some(eth_usdt),
sol: Some(sol_usdt),
usdt: Some(usdt_usdc),
usdc: Some(usdc_usdt),
};
let (program_state_pubkey, _state_bump) =
Pubkey::find_program_address(&[b"BASICORACLE"], &PROGRAM_ID);
let (oracle_pubkey, _oracle_bump) =
Pubkey::find_program_address(&[b"ORACLE_V1_SEED"], &PROGRAM_ID);
let ixn = Instruction {
program_id: basic_oracle::ID,
accounts: vec![
AccountMeta {
pubkey: program_state_pubkey,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: oracle_pubkey,
is_signer: false,
is_writable: true,
},
AccountMeta {
pubkey: runner.function,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: runner.quote,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: runner.signer,
is_signer: true,
is_writable: false,
},
],
data: params.try_to_vec().unwrap_or_default(),
};
vec![ixn]
}
}
// Convert a string to an i128 scaled to 9 decimal places
pub fn parse_string_value(value: &str) -> i128 {
let f64_value = value.parse::<f64>().unwrap();
let sb_decimal = SwitchboardDecimal::from_f64(f64_value);

92
examples/functions/01_basic_oracle/sgx-function/src/instruction.rs
View File

@ -1,92 +0,0 @@
use crate::*;
use crate::binance::Ticker;
pub use switchboard_solana::prelude::*;
pub fn build(
runner: &FunctionRunner,
symbol_str: &str,
ticker: &Ticker,
state_pubkey: &Pubkey,
) -> solana_program::instruction::Instruction {
let symbol = string_to_bytes(symbol_str);
let (program_state_pubkey, _state_bump) =
Pubkey::find_program_address(&[b"BASICORACLE"], &PROGRAM_ID);
let (oracle_pubkey, _oracle_bump) =
Pubkey::find_program_address(&[b"ORACLE_V1_SEED"], &PROGRAM_ID);
let price = ticker.lastPrice.parse::<f64>().unwrap();
let volume = ticker.volume.parse::<f64>().unwrap();
Instruction {
program_id: basic_oracle::ID,
accounts: vec![
AccountMeta {
pubkey: *state_pubkey,
is_signer: false,
is_writable: true,
},
AccountMeta {
pubkey: oracle_pubkey,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: runner.function,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: runner.quote,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: runner.signer,
is_signer: true,
is_writable: false,
},
AccountMeta {
pubkey: runner.payer,
is_signer: true,
is_writable: false,
},
AccountMeta {
pubkey: solana_program::system_program::ID,
is_signer: false,
is_writable: false,
},
AccountMeta {
pubkey: solana_program::sysvar::rent::ID,
is_signer: false,
is_writable: false,
},
],
data: PushDataParams {
symbol,
price,
volume,
oracle_timestamp: unix_timestamp(),
}
.try_to_vec()
.unwrap_or_default(),
}
}
pub fn string_to_bytes(s: &str) -> [u8; 32] {
let mut array = [0; 32];
let bytes = s.as_bytes();
for (&x, p) in bytes.iter().zip(array.iter_mut()) {
*p = x;
}
if bytes.len() > 32 {
eprintln!("Warning: string was longer than 32 bytes, it has been truncated");
}
array
}

14
examples/functions/01_basic_oracle/sgx-function/src/main.rs
View File

@ -3,9 +3,6 @@ pub use switchboard_solana::prelude::*;
pub mod binance;
pub use binance::*;
pub mod instruction;
pub use instruction::*;
pub use basic_oracle::{
self, OracleData, RefreshPrices, RefreshPricesParams, SwitchboardDecimal, ID as PROGRAM_ID,
};
@ -13,17 +10,12 @@ pub use basic_oracle::{
#[tokio::main(worker_threads = 12)]
async fn main() {
// First, initialize the runner instance with a freshly generated Gramine keypair
let runner = FunctionRunner::new_from_cluster(Cluster::Devnet, None).unwrap();
let runner: FunctionRunner = FunctionRunner::new_from_cluster(Cluster::Devnet, None).unwrap();
// Then, write your own Rust logic and build a Vec of instructions.
// Should be under 700 bytes after serialization
let tickers = BinanceTickers::fetch().await.unwrap();
let ixs: Vec<solana_program::instruction::Instruction> = symbols
.iter()
.enumerate()
.map(|(i, s)| instruction::build(&runner, s, tickers.get(i).unwrap(), &state_pubkey))
.collect();
let binance = Binance::fetch().await.unwrap();
let ixs: Vec<Instruction> = binance.to_ixns(&runner);
// Finally, emit the signed quote and partially signed transaction to the functionRunner oracle
// The functionRunner oracle will use the last outputted word to stdout as the serialized result. This is what gets executed on-chain.

17
examples/functions/01_basic_oracle/src/actions/refresh_prices.rs
View File

@ -5,10 +5,11 @@ pub struct RefreshPrices<'info> {
#[account(
seeds = [PROGRAM_SEED],
bump = program.load()?.bump,
constraint = !program.load()?.is_valid_enclave(&quote.load()?.mr_enclave) @ BasicOracleError::InvalidMrEnclave
constraint = program.load()?.is_valid_enclave(&quote.load()?.mr_enclave) @ BasicOracleError::InvalidMrEnclave
)]
pub program: AccountLoader<'info, MyProgramState>,
#[account(
mut,
seeds = [ORACLE_SEED],
bump = oracle.load()?.bump
)]
@ -18,8 +19,8 @@ pub struct RefreshPrices<'info> {
#[account(
seeds = [QUOTE_SEED, function.key().as_ref()],
bump,
seeds::program = SWITCHBOARD_PROGRAM_ID,
bump = quote.load()?.bump,
seeds::program = SWITCHBOARD_ATTESTATION_PROGRAM_ID,
has_one = secured_signer @ BasicOracleError::InvalidTrustedSigner,
constraint =
quote.load()?.mr_enclave != [0u8; 32] @ BasicOracleError::EmptySwitchboardQuote
@ -36,8 +37,6 @@ pub struct RefreshPricesParams {
pub sol: Option<OracleData>,
pub usdt: Option<OracleData>,
pub usdc: Option<OracleData>,
pub doge: Option<OracleData>,
pub near: Option<OracleData>,
}
impl RefreshPrices<'_> {
@ -72,14 +71,6 @@ impl RefreshPrices<'_> {
oracle.usdc = usdc;
}
if let Some(doge) = params.doge {
oracle.doge = doge;
}
if let Some(near) = params.near {
oracle.near = near;
}
Ok(())
}
}

1
examples/functions/01_basic_oracle/src/actions/set_enclaves.rs
View File

@ -4,6 +4,7 @@ use crate::*;
#[instruction(params: SetEnclavesParams)] // rpc parameters hint
pub struct SetEnclaves<'info> {
#[account(
mut,
seeds = [PROGRAM_SEED],
bump = program.load()?.bump,
has_one = authority

190
examples/functions/01_basic_oracle/src/decimal.rs
View File

@ -1,190 +0,0 @@
use crate::*;
use core::cmp::Ordering;
use rust_decimal::Decimal;
#[derive(Default, Eq, PartialEq, Copy, Clone, AnchorSerialize, AnchorDeserialize)]
pub struct BorshDecimal {
pub mantissa: i128,
pub scale: u32,
}
impl From<SwitchboardDecimal> for BorshDecimal {
fn from(s: SwitchboardDecimal) -> Self {
Self {
mantissa: s.mantissa,
scale: s.scale,
}
}
}
impl From<BorshDecimal> for SwitchboardDecimal {
fn from(val: BorshDecimal) -> Self {
SwitchboardDecimal {
mantissa: val.mantissa,
scale: val.scale,
}
}
}
#[zero_copy]
#[derive(Default, Debug, Eq, PartialEq, AnchorDeserialize, AnchorSerialize)]
pub struct SwitchboardDecimal {
/// The part of a floating-point number that represents the significant digits of that number,
/// and that is multiplied by the base, 10, raised to the power of scale to give the actual value of the number.
pub mantissa: i128,
/// The number of decimal places to move to the left to yield the actual value.
pub scale: u32,
}
impl SwitchboardDecimal {
pub fn new(mantissa: i128, scale: u32) -> SwitchboardDecimal {
Self { mantissa, scale }
}
pub fn from_rust_decimal(d: Decimal) -> SwitchboardDecimal {
Self::new(d.mantissa(), d.scale())
}
}
impl From<Decimal> for SwitchboardDecimal {
fn from(val: Decimal) -> Self {
SwitchboardDecimal::new(val.mantissa(), val.scale())
}
}
impl TryInto<Decimal> for &SwitchboardDecimal {
type Error = anchor_lang::error::Error;
fn try_into(self) -> Result<Decimal> {
Decimal::try_from_i128_with_scale(self.mantissa, self.scale)
.map_err(|_| error!(SwitchboardError::DecimalConversionError))
}
}
impl TryInto<Decimal> for SwitchboardDecimal {
type Error = anchor_lang::error::Error;
fn try_into(self) -> Result<Decimal> {
Decimal::try_from_i128_with_scale(self.mantissa, self.scale)
.map_err(|_| error!(SwitchboardError::DecimalConversionError))
}
}
impl Ord for SwitchboardDecimal {
fn cmp(&self, other: &Self) -> Ordering {
let s: Decimal = self.try_into().unwrap();
let other: Decimal = other.try_into().unwrap();
s.cmp(&other)
}
}
impl PartialOrd for SwitchboardDecimal {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
let s: Decimal = self.try_into().unwrap();
let other: Decimal = other.try_into().unwrap();
s.partial_cmp(&other)
}
fn lt(&self, other: &Self) -> bool {
let s: Decimal = self.try_into().unwrap();
let other: Decimal = other.try_into().unwrap();
s < other
}
fn le(&self, other: &Self) -> bool {
let s: Decimal = self.try_into().unwrap();
let other: Decimal = other.try_into().unwrap();
s <= other
}
fn gt(&self, other: &Self) -> bool {
let s: Decimal = self.try_into().unwrap();
let other: Decimal = other.try_into().unwrap();
s > other
}
fn ge(&self, other: &Self) -> bool {
let s: Decimal = self.try_into().unwrap();
let other: Decimal = other.try_into().unwrap();
s >= other
}
}
impl From<SwitchboardDecimal> for bool {
fn from(s: SwitchboardDecimal) -> Self {
let dec: Decimal = (&s).try_into().unwrap();
dec.round().mantissa() != 0
}
}
impl TryInto<u64> for SwitchboardDecimal {
type Error = anchor_lang::error::Error;
fn try_into(self) -> anchor_lang::Result<u64> {
let dec: Decimal = (&self).try_into().unwrap();
dec.try_into()
.map_err(|_| error!(SwitchboardError::IntegerOverflowError))
}
}
impl TryInto<i64> for SwitchboardDecimal {
type Error = anchor_lang::error::Error;
fn try_into(self) -> anchor_lang::Result<i64> {
let dec: Decimal = (&self).try_into().unwrap();
dec.try_into()
.map_err(|_| error!(SwitchboardError::IntegerOverflowError))
}
}
impl TryInto<f64> for SwitchboardDecimal {
type Error = anchor_lang::error::Error;
fn try_into(self) -> anchor_lang::Result<f64> {
let dec: Decimal = (&self).try_into().unwrap();
dec.try_into()
.map_err(|_| error!(SwitchboardError::IntegerOverflowError))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn switchboard_decimal_into_rust_decimal() {
let swb_decimal = &SwitchboardDecimal {
mantissa: 12345,
scale: 2,
};
let decimal: Decimal = swb_decimal.try_into().unwrap();
assert_eq!(decimal.mantissa(), 12345);
assert_eq!(decimal.scale(), 2);
}
#[test]
fn empty_switchboard_decimal_is_false() {
let swb_decimal = SwitchboardDecimal {
mantissa: 0,
scale: 0,
};
let b: bool = swb_decimal.into();
assert_eq!(b, false);
let swb_decimal_neg = SwitchboardDecimal {
mantissa: -0,
scale: 0,
};
let b: bool = swb_decimal_neg.into();
assert_eq!(b, false);
}
#[test]
fn switchboard_decimal_to_u64() {
// 1234.5678
let swb_decimal = SwitchboardDecimal {
mantissa: 12345678,
scale: 4,
};
let b: u64 = swb_decimal.try_into().unwrap();
assert_eq!(b, 1234);
}
#[test]
fn switchboard_decimal_to_f64() {
// 1234.5678
let swb_decimal = SwitchboardDecimal {
mantissa: 12345678,
scale: 4,
};
let b: f64 = swb_decimal.try_into().unwrap();
assert_eq!(b, 1234.5678);
let swb_f64 = SwitchboardDecimal::from_f64(1234.5678);
assert_eq!(swb_decimal, swb_f64);
}
}

31
examples/functions/01_basic_oracle/src/model.rs
View File

@ -14,11 +14,7 @@ impl MyProgramState {
return false;
}
if !self.mr_enclaves.contains(quote_enclave) {
return false;
}
true
self.mr_enclaves.contains(quote_enclave)
}
}
@ -27,18 +23,25 @@ impl MyProgramState {
pub struct OracleData {
pub oracle_timestamp: i64,
pub price: i128,
pub volume: i128,
pub volume_1hr: i128,
pub volume_24hr: i128,
pub twap_1hr: i128,
pub twap_24hr: i128,
}
// impl OracleData {
// pub fn get_fair_price(&self) -> anchor_lang::Result<f64> {
// // Do some logic here based on the twap/vwap
impl OracleData {
pub fn get_fair_price(&self) -> anchor_lang::Result<f64> {
// Do some logic here based on the twap
// let result: f64 = self.price.try_into()?;
// Ok(result)
// }
// }
let price: f64 = SwitchboardDecimal {
mantissa: self.price,
scale: 9,
}
.try_into()?;
Ok(price)
}
}
#[repr(packed)]
#[account(zero_copy)]
@ -50,6 +53,4 @@ pub struct MyOracleState {
pub sol: OracleData,
pub usdt: OracleData,
pub usdc: OracleData,
pub doge: OracleData,
pub near: OracleData,
}

51
examples/functions/01_basic_oracle/src/utils.rs
View File

@ -1,9 +1,48 @@
pub use crate::*;
// TODO: add test for this
pub fn parse_mr_enclaves(enclaves: &Vec<[u8; 32]>) -> Result<[[u8; 32]; 32]> {
enclaves
.clone()
.try_into()
.map_err(|_| error!(BasicOracleError::ArrayOverflow))
pub fn parse_mr_enclaves(enclaves: &Vec<[u8; 32]>) -> anchor_lang::Result<[[u8; 32]; 32]> {
// enclaves
// .clone()
// .try_into()
// .map_err(|_| error!(BasicOracleError::ArrayOverflow))
if enclaves.len() > 32 {
return Err(error!(BasicOracleError::ArrayOverflow));
}
let mut result: [[u8; 32]; 32] = [[0; 32]; 32];
for (i, enclave) in enclaves.iter().enumerate() {
result[i] = *enclave;
}
Ok(result)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_mr_enclaves_success() {
let enclaves: Vec<[u8; 32]> = vec![[1; 32]; 10];
let result = parse_mr_enclaves(&enclaves).unwrap();
// Check first 10 elements are [1; 32]
for i in 0..10 {
assert_eq!(result[i], [1; 32]);
}
// Check the remaining elements are [0; 32] (default)
for i in 10..32 {
assert_eq!(result[i], [0; 32]);
}
}
// #[test]
// fn test_parse_mr_enclaves_overflow() {
// let enclaves: Vec<[u8; 32]> = vec![[1; 32]; 33];
// match parse_mr_enclaves(&enclaves) {
// Err(BasicOracleError::ArrayOverflow) => {} // test passes
// _ => panic!("Unexpected result"), // test fails
// };
// }
}

143
examples/functions/01_basic_oracle/tests/basic_oracle.ts
View File

@ -8,13 +8,18 @@ import {
FunctionAccount,
parseMrEnclave,
MrEnclave,
types,
attestationTypes,
} from "@switchboard-xyz/solana.js";
const unixTimestamp = () => Math.floor(Date.now() / 1000);
// vv1gTnfuUiroqgJHS4xsRASsRQqqixCv1su85VWvcP9
const MRENCLAVE = parseMrEnclave(
Buffer.from("3H98v4rOe5oTewVgg/9u2OoNM9fvPcZxRj2vya0R1p4=", "base64")
Buffer.from("Y6keo0uTCiWDNcWwGjZ2jfTd4VFhrr6LC/6Mk1aiNCA=", "base64")
);
const emptyEnclave: number[] = new Array(32).fill(0);
function has_mr_enclave(
enclaves: Array<MrEnclave>,
@ -79,4 +84,140 @@ describe("basic_oracle", () => {
});
console.log("Your transaction signature", tx);
});
it("Adds an enclave measurement", async () => {
// Add your test here.
const tx = await program.methods
.setEnclaves({ mrEnclaves: [Array.from(MRENCLAVE)] })
.accounts({
program: programStatePubkey,
authority: payer,
})
.rpc()
.catch((err) => {
console.error(err);
throw err;
});
console.log("Your transaction signature", tx);
const programState = await program.account.myProgramState.fetch(
programStatePubkey
);
console.log(
`MrEnclaves:\n\t${programState.mrEnclaves
.filter(
(e) => Buffer.compare(Buffer.from(e), Buffer.from(emptyEnclave)) !== 0
)
.map((e) => `[${e}]`)
.join("\n\t")}`
);
});
it("Oracle refreshes the prices", async () => {
const securedSigner = anchor.web3.Keypair.generate();
const rewardAddress =
await switchboard.attestationQueueAccount.program.mint.getOrCreateAssociatedUser(
payer
);
// TODO: generate function verify ixn
const functionVerifyIxn = attestationTypes.functionVerify(
switchboard.attestationQueueAccount.program,
{
params: {
observedTime: new anchor.BN(unixTimestamp()),
nextAllowedTimestamp: new anchor.BN(unixTimestamp() + 100),
isFailure: false,
mrEnclave: Array.from(MRENCLAVE),
},
},
{
function: functionAccount.publicKey,
fnSigner: securedSigner.publicKey,
securedSigner: switchboard.verifier.signer.publicKey,
verifierQuote: switchboard.verifier.quoteAccount.publicKey,
attestationQueue: switchboard.attestationQueueAccount.publicKey,
escrow: functionAccount.getEscrow(),
receiver: rewardAddress,
verifierPermission: switchboard.verifier.permissionAccount.publicKey,
fnPermission: functionAccount.getPermissionAccount(
switchboard.attestationQueueAccount.publicKey,
payer
)[0].publicKey,
state:
switchboard.attestationQueueAccount.program.attestationProgramState
.publicKey,
payer: payer,
fnQuote: functionAccount.getQuoteAccount()[0].publicKey,
tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
systemProgram: anchor.web3.SystemProgram.programId,
}
);
// Add your test here.
const tx = await program.methods
.refreshOracles({
btc: {
oracleTimestamp: new anchor.BN(0),
price: new anchor.BN("25225000000000"), // 25225
volume: new anchor.BN("1337000000000000"), // 1337000
twap24hr: new anchor.BN("25550000000000"), // 25550
},
eth: {
oracleTimestamp: new anchor.BN(0),
price: new anchor.BN("1815000000000"), // 1815
volume: new anchor.BN("556000000000000"), // 556000
twap24hr: new anchor.BN("1913000000000"), // 1913
},
sol: null,
usdt: null,
usdc: null,
doge: null,
near: null,
})
.accounts({
program: programStatePubkey,
oracle: oraclePubkey,
function: functionAccount.publicKey,
quote: functionAccount.getQuoteAccount()[0].publicKey,
securedSigner: securedSigner.publicKey,
})
.preInstructions([functionVerifyIxn])
.signers([switchboard.verifier.signer, securedSigner])
.rpc()
.catch((err) => {
console.error(err);
throw err;
});
console.log("Your transaction signature", tx);
const oracleState = await program.account.myOracleState.fetch(oraclePubkey);
console.log(`BTC`);
printData(oracleState.btc);
console.log(`ETH`);
printData(oracleState.eth);
console.log(`SOL`);
printData(oracleState.sol);
});
});
function normalizeDecimals(value: anchor.BN) {
return (value ?? new anchor.BN(0))
.div(new anchor.BN(10).pow(new anchor.BN(9)))
.toNumber();
}
function printData(obj: {
oracleTimestamp: anchor.BN;
price: anchor.BN;
volume: anchor.BN;
twap24hr: anchor.BN;
}) {
console.log(
`\tprice: $${normalizeDecimals(obj.price)}\n\tvolume: ${normalizeDecimals(
obj.volume
)}\n\t24Hr Twap: $${normalizeDecimals(obj.twap24hr)}`
);
}

2
rust/switchboard-solana/Cargo.lock generated
View File

@ -3931,7 +3931,7 @@ dependencies = [
[[package]]
name = "switchboard-solana"
version = "0.5.2"
version = "0.5.3"
dependencies = [
"anchor-client",
"anchor-lang",

2
rust/switchboard-solana/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "switchboard-solana"
version = "0.5.2"
version = "0.5.3"
edition = "2021"
description = "A Rust library to interact with Switchboard accounts."
readme = "README.md"

16
rust/switchboard-solana/src/decimal.rs
View File

@ -1,4 +1,4 @@
#![allow(unaligned_references)]
// #![allow(unaligned_references)]
use crate::prelude::*;
use core::cmp::Ordering;
use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
@ -29,7 +29,7 @@ use std::convert::{From, TryInto};
#[zero_copy]
#[repr(packed)]
#[derive(Default, Debug, Eq, PartialEq, AnchorDeserialize, AnchorSerialize)]
#[derive(Default, Debug, Eq, PartialEq, AnchorDeserialize)]
pub struct SwitchboardDecimal {
/// The part of a floating-point number that represents the significant digits of that number, and that is multiplied by the base, 10, raised to the power of scale to give the actual value of the number.
pub mantissa: i128,
@ -49,9 +49,15 @@ impl SwitchboardDecimal {
Self::from_rust_decimal(dec)
}
pub fn scale_to(&self, new_scale: u32) -> i128 {
match self.scale.cmp(&new_scale) {
std::cmp::Ordering::Greater => self.mantissa / 10_i128.pow(self.scale - new_scale),
std::cmp::Ordering::Less => self.mantissa * 10_i128.pow(new_scale - self.scale),
match { self.scale }.cmp(&new_scale) {
std::cmp::Ordering::Greater => self
.mantissa
.checked_div(10_i128.pow(self.scale - new_scale))
.unwrap(),
std::cmp::Ordering::Less => self
.mantissa
.checked_mul(10_i128.pow(new_scale - self.scale))
.unwrap(),
std::cmp::Ordering::Equal => self.mantissa,
}
}

2
rust/switchboard-solana/src/oracle_program/accounts/aggregator.rs
View File

@ -13,7 +13,7 @@ pub struct Hash {
#[zero_copy]
#[repr(packed)]
#[derive(Default, Debug, PartialEq, Eq)]
#[derive(Default, PartialEq, Eq)]
pub struct AggregatorRound {
/// Maintains the number of successful responses received from nodes.
/// Nodes can submit one successful response per round.