An example contract for Solana

Cargo.toml

@@ -6,4 +6,5 @@ members = [
     "pyth-sdk-solana/test-contract",
     "pyth-sdk-cw",
     "examples/cw-contract",
+    "examples/sol-contract"
 ]

examples/sol-contract/.gitignore

@@ -0,0 +1,6 @@
+build/example_sol_contract.so
+build/example_sol_contract-keypair.json
+scripts/invoke.js
+scripts/invoke.js.map
+scripts/node_modules/
+scripts/package-lock.json

examples/sol-contract/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "example-sol-contract"
+version = "0.1.0"
+authors = ["Pyth Data Foundation"]
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+borsh = "0.9"
+pyth-sdk-solana = "0.5.0"
+solana-program = "1.8.1, < 1.11"
+
+[dev-dependencies]
+solana-sdk = "1.8.1, < 1.11"
+solana-client = "1.8.1, < 1.11"
+solana-program-test = "1.8.1, < 1.11"

examples/sol-contract/README.md

@@ -0,0 +1,21 @@
+# Pyth SDK Example Contract for Solana
+
+This repository contains a simple example demonstrating how to read the Pyth price from the Pyth contract on Solana.
+
+The key functionality of this contract is in the `Loan2Value` function in `src/processor.rs`. 
+This function compares the value of some loan and some collateral, which is important in many lending protocols.
+An example invocation of this contract on the Solana devnet can be found in `scripts/invoke.ts`.
+
+We assume that you have installed `cargo`, `solana`, `solana-keygen`, `npm` and `node`.
+
+## Usage
+
+```shell
+> cd examples/sol-contract
+# To build the example contract
+> scripts/build.sh
+# To deploy the example contract
+> scripts/deploy.sh
+# To invoke the example contract
+> scripts/invoke.ts
+```

examples/sol-contract/build/README.md

@@ -0,0 +1 @@
+This directory holds the output of build-bpf. See scripts/build.sh.

examples/sol-contract/scripts/build.sh

@@ -0,0 +1 @@
+cargo build-bpf --sbf-out-dir ./build

examples/sol-contract/scripts/deploy.sh

@@ -0,0 +1 @@
+solana program deploy --program-id build/example_sol_contract-keypair.json build/example_sol_contract.so

examples/sol-contract/scripts/invoke.sh

@@ -0,0 +1 @@
+cd scripts; npm install typescript; npm run build; node invoke.js `solana-keygen pubkey ../build/example_sol_contract-keypair.json`

examples/sol-contract/scripts/invoke.ts

@@ -0,0 +1,52 @@
+const web3 = require("@solana/web3.js");
+const {struct, u8} = require("@solana/buffer-layout");
+
+export const invoke = async (loan: string, collateral: string) => {
+    /* Airdrop */
+    console.log("Airdroping...");
+    let payer = web3.Keypair.generate();
+    let keypair = web3.Keypair.generate();
+    let conn = new web3.Connection(web3.clusterApiUrl('devnet'));
+    let airdropSig = await conn.requestAirdrop(
+        payer.publicKey,
+        web3.LAMPORTS_PER_SOL,
+    );
+    await conn.confirmTransaction(airdropSig);
+
+    /* Specify accounts being touched */
+    const loanKey = new web3.PublicKey(loan);
+    const collateralKey = new web3.PublicKey(collateral);
+    let keys = [{pubkey: loanKey, isSigner: false, isWritable: false},
+                {pubkey: collateralKey, isSigner: false, isWritable: false},
+                {pubkey: keypair.publicKey, isSigner: true, isWritable: false}];
+
+    /* Prepare parameters */
+    let allocateStruct = {
+        index: 0,     // Loan2Value is instruction #0 in the program
+        layout: struct([
+            u8('instruction'),
+        ])
+    };
+    let data = Buffer.alloc(allocateStruct.layout.span);
+    let layoutFields = Object.assign({instruction: allocateStruct.index});
+    allocateStruct.layout.encode(layoutFields, data);
+
+    /* Invoke transaction */
+    let tx = new web3.Transaction({
+        feePayer: payer.publicKey
+    });
+    let contract = process.argv[2];
+    console.log("Invoking contract " + contract + "...");
+    tx.add(new web3.TransactionInstruction({
+        keys,
+        programId: contract,
+        data
+    }));
+
+    let txSig = await web3.sendAndConfirmTransaction(conn, tx, [payer, keypair]);
+    console.log("Confirmed TxHash " + txSig);
+}
+
+let ethToUSD = "EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw";
+let usdtToUSD = "38xoQ4oeJCBrcVvca2cGk7iV1dAfrmTR1kmhSCJQ8Jto";
+invoke(ethToUSD, usdtToUSD);

examples/sol-contract/scripts/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "scripts",
+  "version": "1.0.0",
+  "description": "",
+  "main": "invoke.js",
+  "scripts": {
+    "build": "npx tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^4.8.3"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.56.2"
+  }
+}

examples/sol-contract/scripts/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "target": "es6",
+        "moduleResolution": "node",
+        "sourceMap": true
+    },
+    "lib": ["es2015"]
+}

examples/sol-contract/src/entrypoint.rs

@@ -0,0 +1,20 @@
+//! Program entrypoint
+
+use solana_program::entrypoint;
+use solana_program::pubkey::Pubkey;
+use solana_program::account_info::AccountInfo;
+use solana_program::entrypoint::ProgramResult;
+
+// Every solana program has an entry point function with 3 parameters:
+// the program ID, the accounts being touched by this program,
+// and an arbitrary byte array as the input data for execution.
+entrypoint!(process_instruction);
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    crate::processor::process_instruction(
+        program_id, accounts, instruction_data
+    )
+}

examples/sol-contract/src/instruction.rs

@@ -0,0 +1,11 @@
+//! Program instructions
+
+use borsh::BorshSerialize;
+use borsh::BorshDeserialize;
+
+// A solana program contains a number of instructions.
+// And this example contract contains only one instruction.
+#[derive(Clone, Debug, BorshSerialize, BorshDeserialize, PartialEq)]
+pub enum PythClientInstruction {
+    Loan2Value {}, // In this enum, Loan2Value is number 0.
+}

examples/sol-contract/src/lib.rs

@@ -0,0 +1,5 @@
+// This is the file being compiled to the bpf shared object (.so).
+// It specifies the 3 modules of this example contract.
+pub mod processor;
+pub mod entrypoint;
+pub mod instruction;

examples/sol-contract/src/processor.rs

@@ -0,0 +1,67 @@
+//! Program instruction processor
+
+use solana_program::msg;
+use solana_program::pubkey::Pubkey;
+use solana_program::account_info::AccountInfo;
+use solana_program::entrypoint::ProgramResult;
+use solana_program::program_error::ProgramError;
+
+use borsh::BorshDeserialize;
+use crate::instruction::PythClientInstruction;
+use pyth_sdk_solana::load_price_feed_from_account_info;
+
+pub fn process_instruction(
+    _program_id: &Pubkey,
+    _accounts: &[AccountInfo],
+    input: &[u8],
+) -> ProgramResult {
+    // Checking the validity of parameters is important.
+    // This important step is skipped in this example contract.
+    let instruction = PythClientInstruction::try_from_slice(input)?;
+    match instruction {
+        PythClientInstruction::Loan2Value {} => {
+            let loan = &_accounts[0];
+            let collateral = &_accounts[1];
+            msg!("The loan key is {}.", loan.key);
+            msg!("The collateral key is {}.", collateral.key);
+            msg!("Assume 1 unit of loan and 3000 unit of collateral.");
+            let loan_cnt = 1;
+            let collateral_cnt = 3000;
+
+            // Calculate the value of the loan.
+            // Pyth is called to get the unit price of the loan.
+            let loan_value;
+            let feed1 = load_price_feed_from_account_info(loan)?;
+            let result1 = feed1.get_current_price().ok_or(ProgramError::Custom(0))?;
+            if let Some(v) = result1.price.checked_mul(loan_cnt) {
+                loan_value = v;
+            } else {
+                // An overflow occurs for result1.price * loan_cnt.
+                return Err(ProgramError::Custom(1))
+            }
+
+            // Calculate the value of the collateral.
+            // Pyth is called to get the unit price of the collateral.
+            let collateral_value;
+            let feed2 = load_price_feed_from_account_info(collateral)?;
+            let result2 = feed2.get_current_price().ok_or(ProgramError::Custom(0))?;
+            if let Some(v) = result2.price.checked_mul(collateral_cnt) {
+                collateral_value = v;
+            } else {
+                // An overflow occurs for result2.price * collateral_cnt.
+                return Err(ProgramError::Custom(1))
+            }
+
+            // Check whether the value of the collateral is higher.
+            if collateral_value > loan_value {
+                msg!("Loan unit price is {}.", result1.price);
+                msg!("Collateral unit price is {}.", result2.price);
+                msg!("The value of collateral is higher.");
+                return Ok(())
+            } else {
+                msg!("The value of loan is higher!");
+                return Err(ProgramError::Custom(2))
+            }
+        }
+    }
+}