Add Cross-program invocations (#9582)

2020-04-28 14:33:56 -07:00
parent 063f616a19
commit 068f12fd6f
27 changed files with 2164 additions and 208 deletions
--- a/programs/bpf/rust/invoke/Cargo.toml
+++ b/programs/bpf/rust/invoke/Cargo.toml
@ -0,0 +1,27 @@
+
+# Note: This crate must be built using do.sh
+
+[package]
+name = "solana-bpf-rust-invoke"
+version = "1.0.0"
+description = "Solana BPF test program written in Rust"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+solana-sdk = { path = "../../../../sdk/", version = "1.0.0", default-features = false }
+solana-bpf-rust-invoked = { path = "../invoked"}
+
+[dev_dependencies]
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "1.0.0" }
+
+[features]
+program = ["solana-sdk/program"]
+default = ["program"]
+
+[lib]
+name = "solana_bpf_rust_invoke"
+crate-type = ["cdylib"]
--- a/programs/bpf/rust/invoke/Xargo.toml
+++ b/programs/bpf/rust/invoke/Xargo.toml
@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []
--- a/programs/bpf/rust/invoke/src/lib.rs
+++ b/programs/bpf/rust/invoke/src/lib.rs
@ -0,0 +1,145 @@
+//! @brief Example Rust-based BPF program that issues a cross-program-invocation
+
+#![allow(unreachable_code)]
+
+extern crate solana_sdk;
+
+use solana_bpf_rust_invoked::instruction::create_instruction;
+use solana_sdk::{
+    account_info::AccountInfo,
+    entrypoint,
+    entrypoint::ProgramResult,
+    info,
+    program::{invoke, invoke_signed},
+    program_error::ProgramError,
+    pubkey::Pubkey,
+};
+
+// const MINT_INDEX: usize = 0;
+const ARGUMENT_INDEX: usize = 1;
+const INVOKED_PROGRAM_INDEX: usize = 2;
+const INVOKED_ARGUMENT_INDEX: usize = 3;
+const INVOKED_PROGRAM_DUP_INDEX: usize = 4;
+// const ARGUMENT_DUP_INDEX: usize = 5;
+const DERIVED_KEY_INDEX: usize = 6;
+const DERIVED_KEY2_INDEX: usize = 7;
+
+entrypoint!(process_instruction);
+fn process_instruction(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    _instruction_data: &[u8],
+) -> ProgramResult {
+    info!("invoke Rust program");
+
+    info!("Test data translation");
+    {
+        {
+            let mut data = accounts[ARGUMENT_INDEX].try_borrow_mut_data()?;
+            for i in 0..100 {
+                data[i as usize] = i;
+            }
+        }
+
+        let instruction = create_instruction(
+            *accounts[INVOKED_PROGRAM_INDEX].key,
+            &[
+                (accounts[ARGUMENT_INDEX].key, true, true),
+                (accounts[INVOKED_ARGUMENT_INDEX].key, true, true),
+                (accounts[INVOKED_PROGRAM_INDEX].key, false, false),
+                (accounts[INVOKED_PROGRAM_DUP_INDEX].key, false, false),
+            ],
+            vec![0, 1, 2, 3, 4, 5],
+        );
+        invoke(&instruction, accounts)?;
+    }
+
+    info!("Test return error");
+    {
+        let instruction = create_instruction(
+            *accounts[INVOKED_PROGRAM_INDEX].key,
+            &[(accounts[ARGUMENT_INDEX].key, true, true)],
+            vec![1],
+        );
+        assert_eq!(
+            invoke(&instruction, accounts),
+            Err(ProgramError::Custom(42))
+        );
+    }
+
+    info!("Test derived signers");
+    {
+        assert!(!accounts[DERIVED_KEY_INDEX].is_signer);
+        assert!(!accounts[DERIVED_KEY2_INDEX].is_signer);
+
+        let invoked_instruction = create_instruction(
+            *accounts[INVOKED_PROGRAM_INDEX].key,
+            &[
+                (accounts[DERIVED_KEY_INDEX].key, true, true),
+                (accounts[DERIVED_KEY2_INDEX].key, false, true),
+            ],
+            vec![2],
+        );
+        invoke_signed(
+            &invoked_instruction,
+            accounts,
+            &[&["Lil'", "Bits"], &["Gar Ma Nar Nar"]],
+        )?;
+    }
+
+    info!("Test readonly with writable account");
+    {
+        let invoked_instruction = create_instruction(
+            *accounts[INVOKED_PROGRAM_INDEX].key,
+            &[(accounts[ARGUMENT_INDEX].key, false, true)],
+            vec![3],
+        );
+        invoke(&invoked_instruction, accounts)?;
+    }
+
+    info!("Test nested invoke");
+    {
+        assert!(accounts[ARGUMENT_INDEX].is_signer);
+        assert!(!accounts[DERIVED_KEY_INDEX].is_signer);
+        assert!(!accounts[DERIVED_KEY2_INDEX].is_signer);
+
+        **accounts[ARGUMENT_INDEX].lamports.borrow_mut() -= 5;
+        **accounts[INVOKED_ARGUMENT_INDEX].lamports.borrow_mut() += 5;
+
+        info!("Fist invoke");
+        let instruction = create_instruction(
+            *accounts[INVOKED_PROGRAM_INDEX].key,
+            &[
+                (accounts[ARGUMENT_INDEX].key, true, true),
+                (accounts[INVOKED_ARGUMENT_INDEX].key, true, true),
+                (accounts[DERIVED_KEY_INDEX].key, true, false),
+                (accounts[INVOKED_PROGRAM_DUP_INDEX].key, false, false),
+                (accounts[INVOKED_PROGRAM_DUP_INDEX].key, false, false),
+            ],
+            vec![4],
+        );
+        invoke(&instruction, accounts)?;
+        info!("2nd invoke from first program");
+        invoke(&instruction, accounts)?;
+
+        assert_eq!(accounts[ARGUMENT_INDEX].lamports(), 42 - 5 + 1 + 1 + 1 + 1);
+        assert_eq!(
+            accounts[INVOKED_ARGUMENT_INDEX].lamports(),
+            10 + 5 - 1 - 1 - 1 - 1
+        );
+    }
+
+    info!("Verify data values are retained and updated");
+    {
+        let data = accounts[ARGUMENT_INDEX].try_borrow_data()?;
+        for i in 0..100 {
+            assert_eq!(data[i as usize], i);
+        }
+        let data = accounts[INVOKED_ARGUMENT_INDEX].try_borrow_data()?;
+        for i in 0..10 {
+            assert_eq!(data[i as usize], i);
+        }
+    }
+
+    Ok(())
+}
--- a/programs/bpf/rust/invoked/Cargo.toml
+++ b/programs/bpf/rust/invoked/Cargo.toml
@ -0,0 +1,26 @@
+
+# Note: This crate must be built using do.sh
+
+[package]
+name = "solana-bpf-rust-invoked"
+version = "1.0.0"
+description = "Solana BPF test program written in Rust"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+solana-sdk = { path = "../../../../sdk/", version = "1.0.0", default-features = false }
+
+[dev_dependencies]
+solana-sdk-bpf-test = { path = "../../../../sdk/bpf/rust/test", version = "1.0.0" }
+
+[features]
+program = ["solana-sdk/program"]
+default = ["program"]
+
+[lib]
+name = "solana_bpf_rust_invoked"
+crate-type = ["lib", "cdylib"]
--- a/programs/bpf/rust/invoked/Xargo.toml
+++ b/programs/bpf/rust/invoked/Xargo.toml
@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []
--- a/programs/bpf/rust/invoked/src/instruction.rs
+++ b/programs/bpf/rust/invoked/src/instruction.rs
@ -0,0 +1,28 @@
+//! @brief Example Rust-based BPF program that issues a cross-program-invocation
+
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
+
+pub fn create_instruction(
+    program_id: Pubkey,
+    arguments: &[(&Pubkey, bool, bool)],
+    data: Vec<u8>,
+) -> Instruction {
+    let accounts = arguments
+        .iter()
+        .map(|(key, is_writable, is_signer)| {
+            if *is_writable {
+                AccountMeta::new(**key, *is_signer)
+            } else {
+                AccountMeta::new_readonly(**key, *is_signer)
+            }
+        })
+        .collect();
+    Instruction {
+        program_id,
+        accounts,
+        data,
+    }
+}
--- a/programs/bpf/rust/invoked/src/lib.rs
+++ b/programs/bpf/rust/invoked/src/lib.rs
@ -0,0 +1,160 @@
+//! @brief Example Rust-based BPF program that issues a cross-program-invocation
+
+#![allow(unreachable_code)]
+
+pub mod instruction;
+
+extern crate solana_sdk;
+
+use crate::instruction::create_instruction;
+use solana_sdk::{
+    account_info::AccountInfo, bpf_loader, entrypoint, entrypoint::ProgramResult, info,
+    program::invoke_signed, program_error::ProgramError, pubkey::Pubkey,
+};
+
+entrypoint!(process_instruction);
+#[allow(clippy::cognitive_complexity)]
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    info!("Invoked program");
+
+    match instruction_data[0] {
+        0 => {
+            info!("verify data translations");
+
+            const ARGUMENT_INDEX: usize = 0;
+            const INVOKED_ARGUMENT_INDEX: usize = 1;
+            const INVOKED_PROGRAM_INDEX: usize = 2;
+            const INVOKED_PROGRAM_DUP_INDEX: usize = 3;
+
+            assert_eq!(instruction_data, &[0, 1, 2, 3, 4, 5]);
+            assert_eq!(accounts.len(), 4);
+
+            assert_eq!(accounts[ARGUMENT_INDEX].lamports(), 42);
+            assert_eq!(accounts[ARGUMENT_INDEX].data_len(), 100);
+            assert!(accounts[ARGUMENT_INDEX].is_signer);
+            assert!(accounts[ARGUMENT_INDEX].is_writable);
+            assert_eq!(accounts[ARGUMENT_INDEX].rent_epoch, 1);
+            assert!(!accounts[ARGUMENT_INDEX].executable);
+            {
+                let data = accounts[ARGUMENT_INDEX].try_borrow_data()?;
+                for i in 0..100 {
+                    assert_eq!(data[i as usize], i);
+                }
+            }
+
+            assert_eq!(
+                accounts[INVOKED_ARGUMENT_INDEX].owner,
+                accounts[INVOKED_PROGRAM_INDEX].key
+            );
+            assert_eq!(accounts[INVOKED_ARGUMENT_INDEX].lamports(), 10);
+            assert_eq!(accounts[INVOKED_ARGUMENT_INDEX].data_len(), 10);
+            assert!(accounts[INVOKED_ARGUMENT_INDEX].is_signer);
+            assert!(accounts[INVOKED_ARGUMENT_INDEX].is_writable);
+            assert_eq!(accounts[INVOKED_ARGUMENT_INDEX].rent_epoch, 1);
+            assert!(!accounts[INVOKED_ARGUMENT_INDEX].executable);
+
+            assert_eq!(accounts[INVOKED_PROGRAM_INDEX].key, program_id);
+            assert_eq!(accounts[INVOKED_PROGRAM_INDEX].owner, &bpf_loader::id());
+            assert!(!accounts[INVOKED_PROGRAM_INDEX].is_signer);
+            assert!(!accounts[INVOKED_PROGRAM_INDEX].is_writable);
+            assert_eq!(accounts[INVOKED_PROGRAM_INDEX].rent_epoch, 1);
+            assert!(accounts[INVOKED_PROGRAM_INDEX].executable);
+
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].key,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].key
+            );
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].owner,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].owner
+            );
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].lamports,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].lamports
+            );
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].is_signer,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].is_signer
+            );
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].is_writable,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].is_writable
+            );
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].rent_epoch,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].rent_epoch
+            );
+            assert_eq!(
+                accounts[INVOKED_PROGRAM_INDEX].executable,
+                accounts[INVOKED_PROGRAM_DUP_INDEX].executable
+            );
+            {
+                let data = accounts[INVOKED_PROGRAM_INDEX].try_borrow_data()?;
+                assert!(accounts[INVOKED_PROGRAM_DUP_INDEX]
+                    .try_borrow_mut_data()
+                    .is_err());
+                info!(data[0], 0, 0, 0, 0);
+            }
+        }
+        1 => {
+            info!("return error");
+            return Err(ProgramError::Custom(42));
+        }
+        2 => {
+            info!("verify derived signers");
+            const DERIVED_KEY_INDEX: usize = 0;
+            const DERIVED_KEY2_INDEX: usize = 1;
+
+            assert!(accounts[DERIVED_KEY_INDEX].is_signer);
+            assert!(accounts[DERIVED_KEY2_INDEX].is_signer);
+        }
+        3 => {
+            info!("verify writable");
+            const ARGUMENT_INDEX: usize = 0;
+
+            assert!(!accounts[ARGUMENT_INDEX].is_writable);
+        }
+        4 => {
+            info!("nested invoke");
+
+            const ARGUMENT_INDEX: usize = 0;
+            const INVOKED_ARGUMENT_INDEX: usize = 1;
+            const DERIVED_KEY_INDEX: usize = 2;
+            const INVOKED_PROGRAM_INDEX: usize = 3;
+
+            assert!(accounts[INVOKED_ARGUMENT_INDEX].is_signer);
+
+            **accounts[INVOKED_ARGUMENT_INDEX].lamports.borrow_mut() -= 1;
+            **accounts[ARGUMENT_INDEX].lamports.borrow_mut() += 1;
+            if accounts.len() > 3 {
+                info!("Invoke again");
+                let invoked_instruction = create_instruction(
+                    *accounts[INVOKED_PROGRAM_INDEX].key,
+                    &[
+                        (accounts[ARGUMENT_INDEX].key, true, true),
+                        (accounts[INVOKED_ARGUMENT_INDEX].key, true, true),
+                        (accounts[DERIVED_KEY_INDEX].key, true, true),
+                    ],
+                    vec![4],
+                );
+                invoke_signed(&invoked_instruction, accounts, &[&["Lil'", "Bits"]])?;
+            } else {
+                info!("Last invoked");
+                assert!(accounts[DERIVED_KEY_INDEX].is_signer);
+                {
+                    let mut data = accounts[INVOKED_ARGUMENT_INDEX].try_borrow_mut_data()?;
+                    for i in 0..10 {
+                        data[i as usize] = i;
+                    }
+                }
+            }
+        }
+        _ => panic!(),
+    }
+
+    Ok(())
+}