poc for authenticated calls using arbitrary cpi

.gitignore

@@ -1,3 +1,5 @@
 .anchor/
 /target
 **/.DS_Store
+node_modules/
+test-ledger/

Anchor.toml

@@ -5,6 +5,8 @@ resolution = true
 skip-lint = false
 
 [programs.localnet]
+callable-test = "HyJgPvyuHtXbVkttTbaBUU87sT7iPyHcD6UgUx82gEBq"
+callable-test-2 = "B7apRShjWeCk2j64MFurBzjpnh5YYuNieMVkMZA7joVv"
 protocol_contracts_solana = "ZETAjseVjuFsxdRxo6MmTCvqFwb3ZHUx56Co3vCmGis"
 
 [registry]

programs/callable-test-2/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "callable-test-2"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "callable_test_2"
+
+[features]
+default = []
+cpi = ["no-entrypoint"]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+idl-build = ["anchor-lang/idl-build"]
+
+[dependencies]
+anchor-lang = "0.30.0"

programs/callable-test-2/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

programs/callable-test-2/src/lib.rs

@@ -0,0 +1,20 @@
+use anchor_lang::prelude::*;
+
+declare_id!("B7apRShjWeCk2j64MFurBzjpnh5YYuNieMVkMZA7joVv");
+
+// NOTE: will be removed, wanted to check if discriminator for on_call will be the same
+#[program]
+pub mod callable_test_2 {
+    use super::*;
+
+    pub fn on_call(ctx: Context<OnCall>, sender: Pubkey, data: Vec<u8>) -> Result<()> {
+
+        Ok(())
+    }
+}
+
+#[derive(Accounts)]
+pub struct Initialize {}
+
+#[derive(Accounts)]
+pub struct OnCall {}

programs/callable-test/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "callable-test"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "callable_test"
+
+[features]
+default = []
+cpi = ["no-entrypoint"]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+idl-build = ["anchor-lang/idl-build"]
+
+[dependencies]
+anchor-lang = { version = "=0.30.0" }

programs/callable-test/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

programs/callable-test/src/lib.rs

@@ -0,0 +1,24 @@
+use anchor_lang::prelude::*;
+
+declare_id!("HhLWiKkriQSSZmu1Pfa2tkQD87HosDSFUqeuZKeEc88m");
+
+#[program]
+pub mod callable_test {
+    use super::*;
+
+    pub fn on_call(ctx: Context<OnCall>, sender: Pubkey, data: Vec<u8>) -> Result<()> {
+        // Perform custom logic here based on the received data
+
+        Ok(())
+    }
+}
+
+#[derive(Accounts)]
+pub struct OnCall {}
+
+
+#[account]
+pub struct StorageAccount {
+    pub last_sender: Pubkey,
+    pub last_data: Vec<u8>, // Store the last used data
+}

programs/protocol-contracts-solana/src/lib.rs

@@ -4,6 +4,8 @@ use anchor_spl::token::{transfer, Token, TokenAccount};
 use solana_program::keccak::hash;
 use solana_program::secp256k1_recover::secp256k1_recover;
 use std::mem::size_of;
+use solana_program::instruction::Instruction;
+use solana_program::program::invoke;
 
 #[error_code]
 pub enum Errors {
@@ -25,10 +27,43 @@ pub enum Errors {
     MemoLengthTooShort,
     #[msg("DepositPaused")]
     DepositPaused,
+    #[msg("InvalidInstructionData")]
+    InvalidInstructionData,
 }
 
 declare_id!("ZETAjseVjuFsxdRxo6MmTCvqFwb3ZHUx56Co3vCmGis");
 
+#[repr(C)]
+#[derive(Clone, Debug, PartialEq)]
+pub enum CallableInstruction {
+    OnCall {
+        sender: Pubkey, // this can be struct MessageContext { sender } but this is currently ok
+        data: Vec<u8>,
+    },
+}
+
+impl CallableInstruction {
+    pub fn pack(&self) -> Vec<u8> {
+        let mut buf;
+        match self {
+            CallableInstruction::OnCall { sender, data } => {
+                let data_len = data.len();
+                buf = Vec::with_capacity(41 + data_len); // 41 = 8 (discriminator) + 32 (sender pubkey) + 1 (data length prefix)
+
+                // NOTE: for program to know how to handle instruction after deserialization, discriminator is added
+                // anchor makes discriminator using hash("global:instruction_name") so every contract with on_call instruction should have same discriminator
+                // in case native development is used in target contract, that can be the problem, but probably they can define on_call instruction in this discriminator?
+                buf.extend_from_slice(&[16, 136, 66, 32, 254, 40, 181, 8]);
+                buf.extend_from_slice(&sender.to_bytes());
+                buf.extend_from_slice(&data_len.to_le_bytes()); // have to put length of array so it can be deserialized properly
+                buf.extend_from_slice(data);
+            }
+        }
+        buf
+    }
+}
+
+
 #[program]
 pub mod gateway {
     use super::*;
@@ -287,6 +322,44 @@ pub mod gateway {
 
         Ok(())
     }
+
+    pub fn execute(
+        ctx: Context<Execute>,
+        sender: Pubkey,
+        data: Vec<u8>,
+    ) -> Result<()> {
+        let pda = &mut ctx.accounts.pda;
+        require!(!pda.deposit_paused, Errors::DepositPaused);
+
+        // NOTE: have to manually create Instruction, pack it and invoke since there is no crate for contract
+        // since any contract with on_call instruction can be called
+        let instruction_data = CallableInstruction::OnCall {
+            sender,
+            data,
+        }
+        .pack();
+
+        // NOTE: calling function in other program without passing accounts seems very limitting in what can be done
+        // every account that instruction interacts with has to be predetermined and set before the call, and various callable contracts might have different behavior and need different accounts
+        // also if there is account sent here, we might need to use invoke_signed instead of invoke which also seems not secure with these arbitrary CPIs
+
+        // should we maybe predefine some accounts that can be used in every callable program, or just call without accounts which is really limitting?
+        let ix = Instruction {
+            program_id: ctx.accounts.destination_program.key(),
+            accounts: vec![],
+            data: instruction_data, 
+        };
+
+        invoke(
+            &ix,
+            &[],
+        )?;
+
+
+        msg!("execute successfully");
+
+        Ok(())
+    }
 }
 
 fn recover_eth_address(
@@ -343,6 +416,15 @@ pub struct DepositSplToken<'info> {
     pub to: Account<'info, TokenAccount>, // this must be ATA of PDA
 }
 
+#[derive(Accounts)]
+pub struct Execute<'info> {
+    #[account(mut)]
+    pub signer: Signer<'info>,
+    #[account(mut)]
+    pub pda: Account<'info, Pda>,
+    pub destination_program: AccountInfo<'info>,
+}
+
 #[derive(Accounts)]
 pub struct Withdraw<'info> {
     #[account(mut)]

tests/protocol-contracts-solana.ts

@@ -9,8 +9,7 @@ import { keccak256 } from 'ethereumjs-util';
 import { bufferToHex } from 'ethereumjs-util';
 import {expect} from 'chai';
 import {ecdsaRecover} from 'secp256k1';
-
-
+import { CallableTest } from "../target/types/callable_test";
 
 const ec = new EC('secp256k1');
 // const keyPair = ec.genKeyPair();
@@ -22,6 +21,8 @@ describe("some tests", () => {
     anchor.setProvider(anchor.AnchorProvider.env());
     const conn = anchor.getProvider().connection;
     const gatewayProgram = anchor.workspace.Gateway as Program<Gateway>;
+    const callableProgram = anchor.workspace.CallableTest as Program<CallableTest>;
+
     const wallet = anchor.workspace.Gateway.provider.wallet.payer;
     const mint = anchor.web3.Keypair.generate();
     let tokenAccount: spl.Account;
@@ -71,6 +72,26 @@ describe("some tests", () => {
         }
     });
 
+    it("Calls execute and onCall", async () => {
+        await callableProgram.methods.initialize().rpc();
+
+        // Define the sender's public key and the arbitrary data to pass
+        const senderPubkey = wallet.publicKey;
+        const data = keccak256(Buffer.from("hello"));
+
+        // Call the `execute` function in the gateway program
+        const tx = await gatewayProgram.methods
+        .execute(senderPubkey, data)
+            .accounts({
+            pda: pdaAccount,
+            destinationProgram: callableProgram.programId, // Pass the callable program's ID
+            signer: wallet.publicKey, // The signer of the transaction
+            })
+        .rpc();
+
+        console.log("Transaction signature:", tx);
+    });
+
     it("Mint a SPL USDC token", async () => {
         // now deploying a fake USDC SPL Token
         // 1. create a mint account