feat: Add DelegateWithActions

.github/workflows/run-tests.yml

@@ -51,7 +51,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Run fmt
-        run: cargo fmt -- --check
+        run: rustup component add --toolchain nightly-x86_64-unknown-linux-gnu rustfmt && cargo +nightly fmt -- --check
       - name: Run clippy
         run: cargo clippy -- --deny=warnings
 
@@ -80,7 +80,7 @@ jobs:
         run: |
           cargo build
 
-      - name: run tests
+      - name: run tests (cargo test-sbf)
         run: |
           export PATH="/home/runner/.local/share/solana/install/active_release/bin:$PATH"
           cargo test-sbf --features unit_test_config

Cargo.toml

@@ -17,7 +17,14 @@ name = "dlp"
 
 [features]
 no-entrypoint = []
-sdk = ["no-entrypoint"]
+sdk = [
+    "no-entrypoint",
+    "dep:solana-sdk",
+    "dep:rand",
+    "dep:sha2",
+    "dep:x25519-dalek",
+    "dep:curve25519-dalek",
+]
 program = [
     "dep:pinocchio",
     "dep:pinocchio-log",
@@ -60,7 +67,12 @@ pinocchio-associated-token-account = { version = "0.3.0" , optional = true }
 solana-address = { version = "2.0", features = ["bytemuck", "decode", "syscalls", "curve25519", "std"] }
 
 # manually resolves the conflict with a pinned version of serde
-serde = "=1.0.226"
+serde = { version = "=1.0.226", features = ["derive"] }
+sha2 = { version = "0.10", optional = true }
+x25519-dalek = { version = "2", features = ["static_secrets"], optional = true }
+curve25519-dalek = { version = "4", optional = true }
+solana-sdk = { version = ">=1.16", optional = true }
+rand = { version = "=0.8.5", features = ["small_rng"], optional = true }
 
 [dev-dependencies]
 assertables = "9.8.2"

Makefile

@@ -4,5 +4,8 @@ build:
 test:
 	RUST_LOG=off cargo test-sbf --features unit_test_config
 
+lint:
+	cargo clippy -- --deny=warnings
+
 fmt:
 	cargo +nightly fmt

src/args/delegate.rs

@@ -1,7 +1,10 @@
 use borsh::{BorshDeserialize, BorshSerialize};
+use serde::{Deserialize, Serialize};
 use solana_program::pubkey::Pubkey;
 
-#[derive(Default, Debug, BorshSerialize, BorshDeserialize)]
+#[derive(
+    Default, Debug, BorshSerialize, BorshDeserialize, Serialize, Deserialize,
+)]
 pub struct DelegateArgs {
     /// The frequency at which the validator should commit the account data
     /// if no commit is triggered by the owning program

src/args/delegate_with_actions.rs

@@ -0,0 +1,48 @@
+use serde::{Deserialize, Serialize};
+use solana_program::{instruction::Instruction, pubkey::Pubkey};
+
+use super::DelegateArgs;
+use crate::compact;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DelegateWithActionsArgs {
+    /// Standard delegation parameters.
+    pub delegate: DelegateArgs,
+
+    /// Compact post-delegation actions.
+    pub actions: PostDelegationActions,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PostDelegationActions {
+    /// Number of signer pubkeys in the `pubkeys` prefix.
+    /// First `signer_count` entries of `pubkeys` are required signers.
+    pub signer_count: u8,
+
+    /// Shared pubkey table. Account metas and program IDs reference this table by index.
+    pub pubkeys: Vec<Pubkey>,
+
+    /// Instruction payload in compact cleartext or encrypted bytes.
+    pub instructions: Instructions,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum Instructions {
+    /// Compact cleartext instructions.
+    ClearText {
+        instructions: Vec<compact::Instruction>,
+    },
+
+    /// Encrypted compact instruction bytes.
+    Encrypted { instructions: Vec<u8> },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DecryptedInstructions {
+    /// Sender-provided nonce/salt to randomize ciphertext so identical
+    /// plaintext does not always map to identical encrypted bytes.
+    pub random_salt: u64,
+
+    /// Decrypted instructions ready for execution.
+    pub instructions: Vec<Instruction>,
+}

src/args/mod.rs

@@ -2,6 +2,7 @@ mod call_handler;
 mod commit_state;
 mod delegate;
 mod delegate_ephemeral_balance;
+mod delegate_with_actions;
 mod top_up_ephemeral_balance;
 mod types;
 mod validator_claim_fees;
@@ -11,6 +12,7 @@ pub use call_handler::*;
 pub use commit_state::*;
 pub use delegate::*;
 pub use delegate_ephemeral_balance::*;
+pub use delegate_with_actions::*;
 pub use top_up_ephemeral_balance::*;
 pub use types::*;
 pub use validator_claim_fees::*;

src/compact/account_meta.rs

@@ -0,0 +1,60 @@
+use serde::{Deserialize, Serialize};
+
+const ACCOUNT_INDEX_MASK: u8 = 0b0011_1111;
+const SIGNER_MASK: u8 = 0b0100_0000;
+const WRITABLE_MASK: u8 = 0b1000_0000;
+
+///
+/// MAX_PUBKEYS = 64
+///
+pub const MAX_PUBKEYS: u8 = ACCOUNT_INDEX_MASK + 1;
+
+/// Compact account meta packed into one byte.
+/// Bits `0..=5` encode the pubkey-table index (`0..MAX_PUBKEYS-1`).
+/// Bit `6` is `is_signer`, and bit `7` is `is_writable`.
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct AccountMeta(u8);
+
+impl AccountMeta {
+    pub fn new(index: u8, is_signer: bool) -> Self {
+        Self::try_new(index, is_signer, true).expect("index is out of range")
+    }
+    pub fn new_readonly(index: u8, is_signer: bool) -> Self {
+        Self::try_new(index, is_signer, false).expect("index is out of range")
+    }
+
+    pub fn try_new(
+        index: u8,
+        is_signer: bool,
+        is_writable: bool,
+    ) -> Option<Self> {
+        if index >= MAX_PUBKEYS {
+            return None;
+        }
+        let mut packed = index;
+        if is_signer {
+            packed |= SIGNER_MASK;
+        }
+        if is_writable {
+            packed |= WRITABLE_MASK;
+        }
+        Some(Self(packed))
+    }
+
+    pub fn index(self) -> u8 {
+        self.0 & ACCOUNT_INDEX_MASK
+    }
+
+    pub fn is_signer(self) -> bool {
+        (self.0 & SIGNER_MASK) != 0
+    }
+
+    pub fn is_writable(self) -> bool {
+        (self.0 & WRITABLE_MASK) != 0
+    }
+
+    pub fn set_index(&mut self, new_index: u8) {
+        *self = Self::try_new(new_index, self.is_signer(), self.is_writable())
+            .expect("index is out of range");
+    }
+}

src/compact/instruction.rs

@@ -0,0 +1,39 @@
+use serde::{Deserialize, Serialize};
+
+use crate::compact;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Instruction {
+    pub program_id: u8,
+    pub accounts: Vec<compact::AccountMeta>,
+    pub data: Vec<u8>,
+}
+
+impl Instruction {
+    pub fn from_instruction(
+        ix: solana_program::instruction::Instruction,
+        index_of: &mut impl FnMut(
+            /*account_key*/ solana_program::pubkey::Pubkey,
+            /*signer*/ bool,
+        ) -> u8,
+    ) -> Instruction {
+        Instruction {
+            program_id: index_of(ix.program_id, false),
+
+            accounts: ix
+                .accounts
+                .iter()
+                .map(|meta| {
+                    compact::AccountMeta::try_new(
+                        index_of(meta.pubkey, meta.is_signer),
+                        meta.is_signer,
+                        meta.is_writable,
+                    )
+                    .expect("compact account index must fit in 6 bits")
+                })
+                .collect(),
+
+            data: ix.data,
+        }
+    }
+}

src/compact/mod.rs

@@ -0,0 +1,5 @@
+mod account_meta;
+mod instruction;
+
+pub use account_meta::*;
+pub use instruction::*;

src/discriminator.rs

@@ -53,6 +53,9 @@ pub enum DlpDiscriminator {
 
     /// See [crate::processor::process_commit_finalize_from_buffer] for docs.
     CommitFinalizeFromBuffer = 22,
+
+    /// See [crate::processor::process_delegate_with_actions] for docs.
+    DelegateWithActions = 23,
 }
 
 impl DlpDiscriminator {