program: add a sequence check IX (#908)

Add a sequence check IX

This new IX `SequenceCheck` can be used to avoid having multiple concurrent TX in flight causing unexpected result (multiple borrow for example)

mango_v4.json

@@ -1760,6 +1760,36 @@
         }
       ]
     },
+    {
+      "name": "sequenceCheck",
+      "accounts": [
+        {
+          "name": "group",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "account",
+          "isMut": true,
+          "isSigner": false,
+          "relations": [
+            "group",
+            "owner"
+          ]
+        },
+        {
+          "name": "owner",
+          "isMut": false,
+          "isSigner": true
+        }
+      ],
+      "args": [
+        {
+          "name": "expectedSequenceNumber",
+          "type": "u64"
+        }
+      ]
+    },
     {
       "name": "stubOracleCreate",
       "accounts": [
@@ -7942,12 +7972,16 @@
             ],
             "type": "u64"
           },
+          {
+            "name": "sequenceNumber",
+            "type": "u64"
+          },
           {
             "name": "reserved",
             "type": {
               "array": [
                 "u8",
-                152
+                144
               ]
             }
           },
@@ -9721,12 +9755,16 @@
             "name": "lastCollateralFeeCharge",
             "type": "u64"
           },
+          {
+            "name": "sequenceNumber",
+            "type": "u64"
+          },
           {
             "name": "reserved",
             "type": {
               "array": [
                 "u8",
-                152
+                144
               ]
             }
           }
@@ -11008,6 +11046,9 @@
           },
           {
             "name": "TokenForceWithdraw"
+          },
+          {
+            "name": "SequenceCheck"
           }
         ]
       }
@@ -14350,6 +14391,16 @@
       "code": 6069,
       "name": "TokenAssetLiquidationDisabled",
       "msg": "the asset does not allow liquidation"
+    },
+    {
+      "code": 6070,
+      "name": "BorrowsRequireHealthAccountBank",
+      "msg": "for borrows the bank must be in the health account list"
+    },
+    {
+      "code": 6071,
+      "name": "InvalidSequenceNumber",
+      "msg": "invalid sequence number"
     }
   ]
 }

programs/mango-v4/src/accounts_ix/mod.rs

@@ -45,6 +45,7 @@ pub use perp_place_order::*;
 pub use perp_settle_fees::*;
 pub use perp_settle_pnl::*;
 pub use perp_update_funding::*;
+pub use sequence_check::*;
 pub use serum3_cancel_all_orders::*;
 pub use serum3_cancel_order::*;
 pub use serum3_close_open_orders::*;
@@ -123,6 +124,7 @@ mod perp_place_order;
 mod perp_settle_fees;
 mod perp_settle_pnl;
 mod perp_update_funding;
+mod sequence_check;
 mod serum3_cancel_all_orders;
 mod serum3_cancel_order;
 mod serum3_close_open_orders;

programs/mango-v4/src/accounts_ix/sequence_check.rs

@@ -0,0 +1,20 @@
+use crate::error::*;
+use crate::state::*;
+use anchor_lang::prelude::*;
+
+#[derive(Accounts)]
+pub struct SequenceCheck<'info> {
+    #[account(
+        constraint = group.load()?.is_ix_enabled(IxGate::SequenceCheck) @ MangoError::IxIsDisabled,
+    )]
+    pub group: AccountLoader<'info, Group>,
+
+    #[account(
+        mut,
+        has_one = group,
+        has_one = owner,
+        constraint = account.load()?.is_operational() @ MangoError::AccountIsFrozen
+    )]
+    pub account: AccountLoader<'info, MangoAccountFixed>,
+    pub owner: Signer<'info>,
+}

programs/mango-v4/src/error.rs

@@ -147,6 +147,8 @@ pub enum MangoError {
     TokenAssetLiquidationDisabled,
     #[msg("for borrows the bank must be in the health account list")]
     BorrowsRequireHealthAccountBank,
+    #[msg("invalid sequence number")]
+    InvalidSequenceNumber,
 }
 
 impl MangoError {

programs/mango-v4/src/instructions/ix_gate_set.rs

@@ -96,6 +96,7 @@ pub fn ix_gate_set(ctx: Context<IxGateSet>, ix_gate: u128) -> Result<()> {
     );
     log_if_changed(&group, ix_gate, IxGate::Serum3PlaceOrderV2);
     log_if_changed(&group, ix_gate, IxGate::TokenForceWithdraw);
+    log_if_changed(&group, ix_gate, IxGate::SequenceCheck);
 
     group.ix_gate = ix_gate;
 

programs/mango-v4/src/instructions/mod.rs

@@ -35,6 +35,7 @@ pub use perp_place_order::*;
 pub use perp_settle_fees::*;
 pub use perp_settle_pnl::*;
 pub use perp_update_funding::*;
+pub use sequence_check::*;
 pub use serum3_cancel_all_orders::*;
 pub use serum3_cancel_order::*;
 pub use serum3_cancel_order_by_client_order_id::*;
@@ -104,6 +105,7 @@ mod perp_place_order;
 mod perp_settle_fees;
 mod perp_settle_pnl;
 mod perp_update_funding;
+mod sequence_check;
 mod serum3_cancel_all_orders;
 mod serum3_cancel_order;
 mod serum3_cancel_order_by_client_order_id;

programs/mango-v4/src/instructions/sequence_check.rs

@@ -0,0 +1,18 @@
+use anchor_lang::prelude::*;
+
+use crate::accounts_ix::*;
+use crate::error::MangoError;
+use crate::state::*;
+
+pub fn sequence_check(ctx: Context<SequenceCheck>, expected_sequence_number: u64) -> Result<()> {
+    let mut account = ctx.accounts.account.load_full_mut()?;
+
+    require_eq!(
+        expected_sequence_number,
+        account.fixed.sequence_number,
+        MangoError::InvalidSequenceNumber
+    );
+
+    account.fixed.sequence_number = account.fixed.sequence_number.wrapping_add(1);
+    Ok(())
+}

programs/mango-v4/src/lib.rs

@@ -458,6 +458,15 @@ pub mod mango_v4 {
         Ok(())
     }
 
+    pub fn sequence_check(
+        ctx: Context<SequenceCheck>,
+        expected_sequence_number: u64,
+    ) -> Result<()> {
+        #[cfg(feature = "enable-gpl")]
+        instructions::sequence_check(ctx, expected_sequence_number)?;
+        Ok(())
+    }
+
     // todo:
     // ckamm: generally, using an I80F48 arg will make it harder to call
     // because generic anchor clients won't know how to deal with it

programs/mango-v4/src/state/group.rs

@@ -246,6 +246,7 @@ pub enum IxGate {
     TokenConditionalSwapCreateLinearAuction = 70,
     Serum3PlaceOrderV2 = 71,
     TokenForceWithdraw = 72,
+    SequenceCheck = 73,
     // NOTE: Adding new variants requires matching changes in ts and the ix_gate_set instruction.
 }
 

programs/mango-v4/src/state/mango_account.rs

@@ -157,8 +157,10 @@ pub struct MangoAccount {
     /// Time at which the last collateral fee was charged
     pub last_collateral_fee_charge: u64,
 
+    pub sequence_number: u64,
+
     #[derivative(Debug = "ignore")]
-    pub reserved: [u8; 152],
+    pub reserved: [u8; 144],
 
     // dynamic
     pub header_version: u8,
@@ -212,7 +214,8 @@ impl MangoAccount {
             temporary_delegate: Pubkey::default(),
             temporary_delegate_expiry: 0,
             last_collateral_fee_charge: 0,
-            reserved: [0; 152],
+            sequence_number: 0,
+            reserved: [0; 144],
             header_version: DEFAULT_MANGO_ACCOUNT_VERSION,
             padding3: Default::default(),
             padding4: Default::default(),
@@ -337,11 +340,12 @@ pub struct MangoAccountFixed {
     pub temporary_delegate: Pubkey,
     pub temporary_delegate_expiry: u64,
     pub last_collateral_fee_charge: u64,
-    pub reserved: [u8; 152],
+    pub sequence_number: u64,
+    pub reserved: [u8; 144],
 }
 const_assert_eq!(
     size_of::<MangoAccountFixed>(),
-    32 * 4 + 8 + 8 * 8 + 32 + 8 + 8 + 152
+    32 * 4 + 8 + 8 * 8 + 32 + 8 + 8 + 8 + 144
 );
 const_assert_eq!(size_of::<MangoAccountFixed>(), 400);
 const_assert_eq!(size_of::<MangoAccountFixed>() % 8, 0);
@@ -2909,7 +2913,8 @@ mod tests {
                 temporary_delegate: fixed.temporary_delegate,
                 temporary_delegate_expiry: fixed.temporary_delegate_expiry,
                 last_collateral_fee_charge: fixed.last_collateral_fee_charge,
-                reserved: [0u8; 152],
+                sequence_number: 0,
+                reserved: [0u8; 144],
 
                 header_version: *zerocopy_reader.header_version(),
                 padding3: Default::default(),

programs/mango-v4/tests/cases/test_basic.rs

@@ -947,3 +947,105 @@ async fn test_withdraw_skip_bank() -> Result<(), TransportError> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_sequence_check() -> Result<(), TransportError> {
+    let context = TestContext::new().await;
+    let solana = &context.solana.clone();
+
+    let admin = TestKeypair::new();
+    let owner = context.users[0].key;
+    let payer = context.users[1].key;
+    let mints = &context.mints[0..1];
+
+    let mango_setup::GroupWithTokens { group, .. } = mango_setup::GroupWithTokensConfig {
+        admin,
+        payer,
+        mints: mints.to_vec(),
+        ..mango_setup::GroupWithTokensConfig::default()
+    }
+    .create(solana)
+    .await;
+
+    let account = send_tx(
+        solana,
+        AccountCreateInstruction {
+            account_num: 0,
+            token_count: 6,
+            serum3_count: 3,
+            perp_count: 3,
+            perp_oo_count: 3,
+            token_conditional_swap_count: 3,
+            group,
+            owner,
+            payer,
+        },
+    )
+    .await
+    .unwrap()
+    .account;
+
+    let mango_account = get_mango_account(solana, account).await;
+    assert_eq!(mango_account.fixed.sequence_number, 0);
+
+    //
+    // TEST: Sequence check with right sequence number
+    //
+
+    send_tx(
+        solana,
+        SequenceCheckInstruction {
+            account,
+            owner,
+            expected_sequence_number: 0,
+        },
+    )
+    .await
+    .unwrap();
+
+    let mango_account = get_mango_account(solana, account).await;
+    assert_eq!(mango_account.fixed.sequence_number, 1);
+
+    send_tx(
+        solana,
+        SequenceCheckInstruction {
+            account,
+            owner,
+            expected_sequence_number: 1,
+        },
+    )
+    .await
+    .unwrap();
+
+    let mango_account = get_mango_account(solana, account).await;
+    assert_eq!(mango_account.fixed.sequence_number, 2);
+
+    //
+    // TEST: Sequence check with wrong sequence number
+    //
+
+    send_tx_expect_error!(
+        solana,
+        SequenceCheckInstruction {
+            account,
+            owner,
+            expected_sequence_number: 1
+        },
+        MangoError::InvalidSequenceNumber
+    );
+
+    send_tx_expect_error!(
+        solana,
+        SequenceCheckInstruction {
+            account,
+            owner,
+            expected_sequence_number: 4
+        },
+        MangoError::InvalidSequenceNumber
+    );
+
+    let mango_account = get_mango_account(solana, account).await;
+    assert_eq!(mango_account.fixed.sequence_number, 2);
+
+    Ok(())
+}