use concrete type over trait

Author: redmannequin

programs/system/src/instructions/allocate_with_seed.rs

@@ -1,6 +1,6 @@
 use pinocchio::{account_info::AccountInfo, instruction::AccountMeta, pubkey::Pubkey};
 
-use crate::InvokeParts;
+use crate::{InstructionData, InvokeParts};
 
 /// Allocate space for and assign an account at an address derived
 /// from a base public key and a seed.
@@ -33,39 +33,36 @@ const N_ACCOUNTS: usize = 2;
 const N_ACCOUNT_METAS: usize = 2;
 const DATA_LEN: usize = 112;
 
-impl<'a, 'b, 'c> InvokeParts for AllocateWithSeed<'a, 'b, 'c> {
-    type Accounts = [&'a AccountInfo; N_ACCOUNTS];
-    type AccountMetas = [AccountMeta<'a>; N_ACCOUNT_METAS];
-    type InstructionData = [u8; DATA_LEN];
+impl<'a, 'b, 'c> From<AllocateWithSeed<'a, 'b, 'c>>
+    for InvokeParts<'a, N_ACCOUNTS, N_ACCOUNT_METAS, DATA_LEN>
+{
+    fn from(value: AllocateWithSeed<'a, 'b, 'c>) -> Self {
+        Self {
+            accounts: [value.account, value.base],
+            account_metas: [
+                AccountMeta::writable_signer(value.account.key()),
+                AccountMeta::readonly_signer(value.base.key()),
+            ],
+            instruction_data: {
+                // instruction data
+                // - [0..4  ]: instruction discriminator
+                // - [4..36 ]: base pubkey
+                // - [36..44]: seed length
+                // - [44..  ]: seed (max 32)
+                // - [..  +8]: account space
+                // - [.. +32]: owner pubkey
+                let mut instruction_data = [0; DATA_LEN];
+                instruction_data[0] = 9;
+                instruction_data[4..36].copy_from_slice(value.base.key());
+                instruction_data[36..44]
+                    .copy_from_slice(&u64::to_le_bytes(value.seed.len() as u64));
 
-    fn accounts(&self) -> Self::Accounts {
-        [self.account, self.base]
-    }
-
-    fn account_metas(&self) -> Self::AccountMetas {
-        [
-            AccountMeta::writable_signer(self.account.key()),
-            AccountMeta::readonly_signer(self.base.key()),
-        ]
-    }
-
-    fn instruction_data(&self) -> (Self::InstructionData, usize) {
-        // instruction data
-        // - [0..4  ]: instruction discriminator
-        // - [4..36 ]: base pubkey
-        // - [36..44]: seed length
-        // - [44..  ]: seed (max 32)
-        // - [..  +8]: account space
-        // - [.. +32]: owner pubkey
-        let mut instruction_data = [0; DATA_LEN];
-        instruction_data[0] = 9;
-        instruction_data[4..36].copy_from_slice(self.base.key());
-        instruction_data[36..44].copy_from_slice(&u64::to_le_bytes(self.seed.len() as u64));
-
-        let offset = 44 + self.seed.len();
-        instruction_data[44..offset].copy_from_slice(self.seed.as_bytes());
-        instruction_data[offset..offset + 8].copy_from_slice(&self.space.to_le_bytes());
-        instruction_data[offset + 8..offset + 40].copy_from_slice(self.owner.as_ref());
-        (instruction_data, offset + 40)
+                let offset = 44 + value.seed.len();
+                instruction_data[44..offset].copy_from_slice(value.seed.as_bytes());
+                instruction_data[offset..offset + 8].copy_from_slice(&value.space.to_le_bytes());
+                instruction_data[offset + 8..offset + 40].copy_from_slice(value.owner.as_ref());
+                InstructionData::Truncated((instruction_data, offset + 40))
+            },
+        }
     }
 }

programs/system/src/instructions/transfer.rs

@@ -1,6 +1,6 @@
 use pinocchio::{account_info::AccountInfo, instruction::AccountMeta};
 
-use crate::InvokeParts;
+use crate::{InstructionData, InvokeParts};
 
 /// Transfer lamports.
 ///
@@ -22,29 +22,23 @@ const N_ACCOUNTS: usize = 2;
 const N_ACCOUNT_METAS: usize = 2;
 const DATA_LEN: usize = 12;
 
-impl<'a> InvokeParts for Transfer<'a> {
-    type Accounts = [&'a AccountInfo; N_ACCOUNTS];
-    type AccountMetas = [AccountMeta<'a>; N_ACCOUNT_METAS];
-    type InstructionData = [u8; DATA_LEN];
-
-    fn accounts(&self) -> Self::Accounts {
-        [self.to, self.from]
-    }
-
-    fn account_metas(&self) -> Self::AccountMetas {
-        [
-            AccountMeta::writable_signer(self.from.key()),
-            AccountMeta::writable(self.to.key()),
-        ]
-    }
-
-    fn instruction_data(&self) -> (Self::InstructionData, usize) {
-        // instruction data
-        // -  [0..4 ]: instruction discriminator
-        // -  [4..12]: lamports amount
-        let mut instruction_data = [0; DATA_LEN];
-        instruction_data[0] = 2;
-        instruction_data[4..12].copy_from_slice(&self.lamports.to_le_bytes());
-        (instruction_data, DATA_LEN)
+impl<'a> From<Transfer<'a>> for InvokeParts<'a, N_ACCOUNTS, N_ACCOUNT_METAS, DATA_LEN> {
+    fn from(value: Transfer<'a>) -> Self {
+        InvokeParts {
+            accounts: [value.to, value.from],
+            account_metas: [
+                AccountMeta::writable_signer(value.from.key()),
+                AccountMeta::writable(value.to.key()),
+            ],
+            instruction_data: {
+                // instruction data
+                // -  [0..4 ]: instruction discriminator
+                // -  [4..12]: lamports amount
+                let mut instruction_data = [0; DATA_LEN];
+                instruction_data[0] = 2;
+                instruction_data[4..12].copy_from_slice(&value.lamports.to_le_bytes());
+                InstructionData::Full(instruction_data)
+            },
+        }
     }
 }

programs/system/src/lib.rs

@@ -11,61 +11,64 @@ pub mod instructions;
 
 pinocchio_pubkey::declare_id!("11111111111111111111111111111111");
 
-pub trait InvokeParts {
-    type Accounts;
-    type AccountMetas;
-    type InstructionData;
+pub struct InvokeParts<'a, const N: usize, const M: usize, const J: usize> {
+    pub accounts: [&'a AccountInfo; N],
+    pub account_metas: [AccountMeta<'a>; M],
+    pub instruction_data: InstructionData<J>,
+}
+
+pub enum InstructionData<const N: usize> {
+    Full([u8; N]),
+    Truncated(([u8; N], usize)),
+}
 
-    fn accounts(&self) -> Self::Accounts;
-    fn account_metas(&self) -> Self::AccountMetas;
-    fn instruction_data(&self) -> (Self::InstructionData, usize);
+impl<const N: usize> InstructionData<N> {
+    pub fn data(&self) -> &[u8] {
+        match *self {
+            InstructionData::Full(ref data) => data,
+            InstructionData::Truncated((ref data, end)) => &data[..end],
+        }
+    }
 }
 
-pub trait Invoke<const N: usize>: Sized {
+pub trait Invoke<'a, const N: usize, const M: usize, const J: usize>:
+    Into<InvokeParts<'a, N, M, J>>
+{
     fn invoke(self) -> pinocchio::ProgramResult {
         self.invoke_signed(&[])
     }
 
     fn invoke_signed(self, signers: &[Signer]) -> pinocchio::ProgramResult {
-        self.invoke_invoker(signers, |ix, acc, sigs| cpi::invoke_signed(&ix, acc, sigs))
+        Self::invoke_invoker(self.into(), signers, |ix, acc, sigs| {
+            cpi::invoke_signed(&ix, acc, sigs)
+        })
     }
 
     unsafe fn invoke_access_unchecked(self) -> pinocchio::ProgramResult {
         self.invoke_singed_access_unchecked(&[])
     }
 
     unsafe fn invoke_singed_access_unchecked(self, signers: &[Signer]) -> pinocchio::ProgramResult {
-        self.invoke_invoker(signers, |ix, acc, sigs| unsafe {
+        Self::invoke_invoker(self.into(), signers, |ix, acc, sigs| unsafe {
             cpi::invoke_signed_access_unchecked(&ix, acc, sigs)
         })
     }
 
     fn invoke_invoker(
-        self,
-        signers: &[Signer],
-        invoker: impl FnOnce(Instruction, &[&AccountInfo; N], &[Signer]) -> pinocchio::ProgramResult,
-    ) -> pinocchio::ProgramResult;
-}
-
-impl<'a, const N: usize, const M: usize, const J: usize, T> Invoke<N> for T
-where
-    T: InvokeParts<
-        Accounts = [&'a AccountInfo; N],
-        AccountMetas = [AccountMeta<'a>; M],
-        InstructionData = [u8; J],
-    >,
-{
-    fn invoke_invoker(
-        self,
+        invoke_parts: InvokeParts<'a, N, M, J>,
         signers: &[Signer],
         invoker: impl FnOnce(Instruction, &[&AccountInfo; N], &[Signer]) -> pinocchio::ProgramResult,
     ) -> pinocchio::ProgramResult {
-        let (data, end) = self.instruction_data();
         let instruction = Instruction {
             program_id: &crate::ID,
-            accounts: &self.account_metas(),
-            data: &data[..end],
+            accounts: &invoke_parts.account_metas,
+            data: invoke_parts.instruction_data.data(),
         };
-        invoker(instruction, &self.accounts(), signers)
+        invoker(instruction, &invoke_parts.accounts, signers)
     }
 }
+
+impl<'a, const N: usize, const M: usize, const J: usize, T> Invoke<'a, N, M, J> for T where
+    InvokeParts<'a, N, M, J>: From<T>
+{
+}