swift upgrade for delegates (#1546)

* swift: set taker pubkey for delegates

* upgrade swift with delegates

* fix tests

* changelog

Author: NourAlharithi

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - program: fix reference price offset reserves ([#1516](https://github.com/drift-labs/protocol-v2/pull/1516))
 - sdk: account for authority when useMarketLastSlotCache ([#1541](https://github.com/drift-labs/protocol-v2/pull/1541))
+- program: delegate wallets sign taker pubkey into message ([#1546](https://github.com/drift-labs/protocol-v2/pull/1546))
 
 ### Breaking
 

programs/drift/src/instructions/keeper.rs

@@ -62,7 +62,7 @@ use crate::state::user::{
     MarginMode, MarketType, OrderStatus, OrderTriggerCondition, OrderType, User, UserStats,
 };
 use crate::state::user_map::{load_user_map, load_user_maps, UserMap, UserStatsMap};
-use crate::validation::sig_verification::verify_ed25519_msg;
+use crate::validation::sig_verification::verify_and_decode_ed25519_msg;
 use crate::validation::user::{validate_user_deletion, validate_user_is_idle};
 use crate::{
     controller, load, math, print_error, safe_decrement, OracleSource, GOV_SPOT_MARKET_INDEX,
@@ -665,44 +665,51 @@ pub fn place_signed_msg_taker_order<'c: 'info, 'info>(
     // Verify data from verify ix
     let ix: Instruction = load_instruction_at_checked(ix_idx as usize - 1, ix_sysvar)?;
 
-    let signer = match is_delegate_signer {
-        true => taker.delegate.to_bytes(),
-        false => taker.authority.to_bytes(),
+    let signer = if is_delegate_signer {
+        taker.delegate.to_bytes()
+    } else {
+        taker.authority.to_bytes()
     };
-    let verified_message_and_signature = verify_ed25519_msg(
+    let verified_message_and_signature = verify_and_decode_ed25519_msg(
         &ix,
         ix_sysvar,
         ix_idx,
         &signer,
         &taker_order_params_message_bytes[..],
+        is_delegate_signer,
     )?;
 
-    let taker_order_params_message: SignedMsgOrderParamsMessage =
-        verified_message_and_signature.signed_msg_order_params_message;
-
-    // Verify taker passed to the ix matches pda derived from subaccount id + authority
-    let taker_pda = Pubkey::find_program_address(
-        &[
-            "user".as_bytes(),
-            &taker.authority.to_bytes(),
-            &taker_order_params_message.sub_account_id.to_le_bytes(),
-        ],
-        &ID,
-    );
-    if taker_pda.0 != taker_key {
-        msg!(
-            "Taker key {:?} does not match pda {:?}",
-            taker_key,
-            taker_pda.0
+    if is_delegate_signer {
+        validate!(
+            verified_message_and_signature.delegate_signed_taker_pubkey == Some(taker_key),
+            ErrorCode::SignedMsgUserContextUserMismatch,
+            "Delegate signed msg for taker pubkey different than supplied pubkey"
+        )?;
+    } else {
+        // Verify taker passed to the ix matches pda derived from subaccount id + authority
+        let taker_pda = Pubkey::find_program_address(
+            &[
+                "user".as_bytes(),
+                &taker.authority.to_bytes(),
+                &verified_message_and_signature
+                    .sub_account_id
+                    .unwrap()
+                    .to_le_bytes(),
+            ],
+            &ID,
         );
-        return Err(ErrorCode::SignedMsgUserContextUserMismatch.into());
-    }
+        validate!(
+            taker_pda.0 == taker_key,
+            ErrorCode::SignedMsgUserContextUserMismatch,
+            "Taker key does not match pda"
+        )?;
+    };
 
     let signature = verified_message_and_signature.signature;
     let clock = &Clock::get()?;
 
     // First order must be a taker order
-    let matching_taker_order_params = &taker_order_params_message.signed_msg_order_params;
+    let matching_taker_order_params = &verified_message_and_signature.signed_msg_order_params;
     if matching_taker_order_params.market_type != MarketType::Perp
         || !matching_taker_order_params.has_valid_auction_params()?
     {
@@ -720,7 +727,7 @@ pub fn place_signed_msg_taker_order<'c: 'info, 'info>(
     }
 
     // Set max slot for the order early so we set correct signed msg order id
-    let order_slot = taker_order_params_message.slot;
+    let order_slot = verified_message_and_signature.slot;
     if order_slot < clock.slot.saturating_sub(500) {
         msg!(
             "SignedMsg order slot {} is too old: must be within 500 slots of current slot",
@@ -749,7 +756,7 @@ pub fn place_signed_msg_taker_order<'c: 'info, 'info>(
     // Dont place order if signed msg order already exists
     let mut taker_order_id_to_use = taker.next_order_id;
     let mut signed_msg_order_id =
-        SignedMsgOrderId::new(taker_order_params_message.uuid, max_slot, 0);
+        SignedMsgOrderId::new(verified_message_and_signature.uuid, max_slot, 0);
     if signed_msg_account
         .check_exists_and_prune_stale_signed_msg_order_ids(signed_msg_order_id, clock.slot)
     {
@@ -758,7 +765,7 @@ pub fn place_signed_msg_taker_order<'c: 'info, 'info>(
     }
 
     // Good to place orders, do stop loss and take profit orders first
-    if let Some(stop_loss_order_params) = taker_order_params_message.stop_loss_order_params {
+    if let Some(stop_loss_order_params) = verified_message_and_signature.stop_loss_order_params {
         taker_order_id_to_use += 1;
         let stop_loss_order = OrderParams {
             order_type: OrderType::TriggerMarket,
@@ -793,7 +800,8 @@ pub fn place_signed_msg_taker_order<'c: 'info, 'info>(
         )?;
     }
 
-    if let Some(take_profit_order_params) = taker_order_params_message.take_profit_order_params {
+    if let Some(take_profit_order_params) = verified_message_and_signature.take_profit_order_params
+    {
         taker_order_id_to_use += 1;
         let take_profit_order = OrderParams {
             order_type: OrderType::TriggerMarket,

programs/drift/src/state/order_params.rs

@@ -733,6 +733,16 @@ pub struct SignedMsgOrderParamsMessage {
     pub stop_loss_order_params: Option<SignedMsgTriggerOrderParams>,
 }
 
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Default, Eq, PartialEq, Debug)]
+pub struct SignedMsgOrderParamsDelegateMessage {
+    pub signed_msg_order_params: OrderParams,
+    pub taker_pubkey: Pubkey,
+    pub slot: u64,
+    pub uuid: [u8; 8],
+    pub take_profit_order_params: Option<SignedMsgTriggerOrderParams>,
+    pub stop_loss_order_params: Option<SignedMsgTriggerOrderParams>,
+}
+
 #[derive(AnchorSerialize, AnchorDeserialize, Clone, Default, Eq, PartialEq, Debug)]
 pub struct SignedMsgTriggerOrderParams {
     pub trigger_price: u64,

programs/drift/src/validation/sig_verification.rs

@@ -1,5 +1,8 @@
 use crate::error::ErrorCode;
-use crate::state::order_params::SignedMsgOrderParamsMessage;
+use crate::state::order_params::{
+    OrderParams, SignedMsgOrderParamsDelegateMessage, SignedMsgOrderParamsMessage,
+    SignedMsgTriggerOrderParams,
+};
 use anchor_lang::prelude::*;
 use bytemuck::try_cast_slice;
 use bytemuck::{Pod, Zeroable};
@@ -10,6 +13,7 @@ use solana_program::instruction::Instruction;
 use solana_program::program_memory::sol_memcmp;
 use solana_program::sysvar;
 use std::convert::TryInto;
+use std::f32::consts::E;
 
 const ED25519_PROGRAM_INPUT_HEADER_LEN: usize = 2;
 
@@ -43,7 +47,13 @@ pub struct Ed25519SignatureOffsets {
 }
 
 pub struct VerifiedMessage {
-    pub signed_msg_order_params_message: SignedMsgOrderParamsMessage,
+    pub signed_msg_order_params: OrderParams,
+    pub sub_account_id: Option<u16>,
+    pub delegate_signed_taker_pubkey: Option<Pubkey>,
+    pub slot: u64,
+    pub uuid: [u8; 8],
+    pub take_profit_order_params: Option<SignedMsgTriggerOrderParams>,
+    pub stop_loss_order_params: Option<SignedMsgTriggerOrderParams>,
     pub signature: [u8; 64],
 }
 
@@ -59,12 +69,13 @@ fn slice_eq(a: &[u8], b: &[u8]) -> bool {
 ///
 /// `pubkey` expected pubkey of the signer
 ///
-pub fn verify_ed25519_msg(
+pub fn verify_and_decode_ed25519_msg(
     ed25519_ix: &Instruction,
     instructions_sysvar: &AccountInfo,
     current_ix_index: u16,
     signer: &[u8; 32],
     msg: &[u8],
+    is_delegate_signer: bool,
 ) -> Result<VerifiedMessage> {
     if ed25519_ix.program_id != ED25519_ID || ed25519_ix.accounts.len() != 0 {
         msg!("Invalid Ix: program ID: {:?}", ed25519_ix.program_id);
@@ -221,13 +232,46 @@ pub fn verify_ed25519_msg(
 
     let payload =
         hex::decode(payload).map_err(|_| SignatureVerificationError::InvalidMessageHex)?;
-    Ok(VerifiedMessage {
-        signed_msg_order_params_message: SignedMsgOrderParamsMessage::deserialize(
+
+    if is_delegate_signer {
+        let deserialized = SignedMsgOrderParamsDelegateMessage::deserialize(
+            &mut &payload[8..], // 8 byte manual discriminator
+        )
+        .map_err(|_| {
+            msg!("Invalid message encoding for is_delegate_signer = true");
+            SignatureVerificationError::InvalidMessageDataSize
+        })?;
+
+        return Ok(VerifiedMessage {
+            signed_msg_order_params: deserialized.signed_msg_order_params,
+            sub_account_id: None,
+            delegate_signed_taker_pubkey: Some(deserialized.taker_pubkey),
+            slot: deserialized.slot,
+            uuid: deserialized.uuid,
+            take_profit_order_params: deserialized.take_profit_order_params,
+            stop_loss_order_params: deserialized.stop_loss_order_params,
+            signature: *signature,
+        });
+    } else {
+        let deserialized = SignedMsgOrderParamsMessage::deserialize(
             &mut &payload[8..], // 8 byte manual discriminator
         )
-        .unwrap(),
-        signature: *signature,
-    })
+        .map_err(|_| {
+            msg!("Invalid delegate message encoding for with is_delegate_signer = false");
+            SignatureVerificationError::InvalidMessageDataSize
+        })?;
+
+        return Ok(VerifiedMessage {
+            signed_msg_order_params: deserialized.signed_msg_order_params,
+            sub_account_id: Some(deserialized.sub_account_id),
+            delegate_signed_taker_pubkey: None,
+            slot: deserialized.slot,
+            uuid: deserialized.uuid,
+            take_profit_order_params: deserialized.take_profit_order_params,
+            stop_loss_order_params: deserialized.stop_loss_order_params,
+            signature: *signature,
+        });
+    }
 }
 
 #[error_code]

sdk/src/driftClient.ts

@@ -57,6 +57,7 @@ import {
 	UserAccount,
 	UserStatsAccount,
 	ProtectedMakerModeConfig,
+	SignedMsgOrderParamsDelegateMessage,
 } from './types';
 import driftIDL from './idl/drift.json';
 
@@ -6323,9 +6324,15 @@ export class DriftClient {
 	}
 
 	public signSignedMsgOrderParamsMessage(
-		orderParamsMessage: SignedMsgOrderParamsMessage
+		orderParamsMessage:
+			| SignedMsgOrderParamsMessage
+			| SignedMsgOrderParamsDelegateMessage,
+		delegateSigner?: boolean
 	): SignedMsgOrderParams {
-		const borshBuf = this.encodeSignedMsgOrderParamsMessage(orderParamsMessage);
+		const borshBuf = this.encodeSignedMsgOrderParamsMessage(
+			orderParamsMessage,
+			delegateSigner
+		);
 		const orderParams = Buffer.from(borshBuf.toString('hex'));
 		return {
 			orderParams,
@@ -6337,16 +6344,24 @@ export class DriftClient {
 	 * Borsh encode signedMsg taker order params
 	 */
 	public encodeSignedMsgOrderParamsMessage(
-		orderParamsMessage: SignedMsgOrderParamsMessage
+		orderParamsMessage:
+			| SignedMsgOrderParamsMessage
+			| SignedMsgOrderParamsDelegateMessage,
+		delegateSigner?: boolean
 	): Buffer {
 		const anchorIxName = 'global' + ':' + 'SignedMsgOrderParamsMessage';
 		const prefix = Buffer.from(sha256(anchorIxName).slice(0, 8));
 		const buf = Buffer.concat([
 			prefix,
-			this.program.coder.types.encode(
-				'SignedMsgOrderParamsMessage',
-				orderParamsMessage
-			),
+			delegateSigner
+				? this.program.coder.types.encode(
+						'SignedMsgOrderParamsDelegateMessage',
+						orderParamsMessage as SignedMsgOrderParamsDelegateMessage
+				  )
+				: this.program.coder.types.encode(
+						'SignedMsgOrderParamsMessage',
+						orderParamsMessage as SignedMsgOrderParamsMessage
+				  ),
 		]);
 		return buf;
 	}

sdk/src/idl/drift.json

@@ -9531,6 +9531,53 @@
         ]
       }
     },
+    {
+      "name": "SignedMsgOrderParamsDelegateMessage",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "signedMsgOrderParams",
+            "type": {
+              "defined": "OrderParams"
+            }
+          },
+          {
+            "name": "takerPubkey",
+            "type": "publicKey"
+          },
+          {
+            "name": "slot",
+            "type": "u64"
+          },
+          {
+            "name": "uuid",
+            "type": {
+              "array": [
+                "u8",
+                8
+              ]
+            }
+          },
+          {
+            "name": "takeProfitOrderParams",
+            "type": {
+              "option": {
+                "defined": "SignedMsgTriggerOrderParams"
+              }
+            }
+          },
+          {
+            "name": "stopLossOrderParams",
+            "type": {
+              "option": {
+                "defined": "SignedMsgTriggerOrderParams"
+              }
+            }
+          }
+        ]
+      }
+    },
     {
       "name": "SignedMsgTriggerOrderParams",
       "type": {

sdk/src/types.ts

@@ -1174,6 +1174,15 @@ export type SignedMsgOrderParamsMessage = {
 	stopLossOrderParams: SignedMsgTriggerOrderParams | null;
 };
 
+export type SignedMsgOrderParamsDelegateMessage = {
+	signedMsgOrderParams: OrderParams;
+	slot: BN;
+	uuid: Uint8Array;
+	takerPubkey: PublicKey;
+	takeProfitOrderParams: SignedMsgTriggerOrderParams | null;
+	stopLossOrderParams: SignedMsgTriggerOrderParams | null;
+};
+
 export type SignedMsgTriggerOrderParams = {
 	triggerPrice: BN;
 	baseAssetAmount: BN;