@glamsystems/glam-sdk 0.1.25 → 0.1.26

package/index.cjs.js

@@ -7,9 +7,9 @@ var splTokenMetadata = require('@solana/spl-token-metadata');
 var DLMM = require('@meteora-ag/dlmm');
 var sanctumLstList = require('sanctum-lst-list');
 var bytes = require('@coral-xyz/anchor/dist/cjs/utils/bytes');
+var borsh = require('@coral-xyz/borsh');
 var marinadeTsSdk = require('@marinade.finance/marinade-ts-sdk');
 var splStakePool = require('@solana/spl-stake-pool');
-var borsh = require('@coral-xyz/borsh');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -34,7 +34,7 @@ var borsh__namespace = /*#__PURE__*/_interopNamespaceDefault(borsh);
 var address = "GLAMbTqav9N9witRjswJ8enwp9vv5G8bsSJ2kPJ4rcyc";
 var metadata = {
     name: "glam_protocol",
-    version: "0.4.24",
+    version: "0.4.28",
     spec: "0.1.0",
     description: "Glam Protocol"
 };
@@ -1524,35 +1524,393 @@ var instructions = [
             },
             {
                 name: "cpi_program",
-                address: "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+                address: "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+            },
+            {
+                name: "user",
+                writable: true
+            }
+        ],
+        args: [
+            {
+                name: "sub_account_id",
+                type: "u16"
+            },
+            {
+                name: "delegate",
+                type: "pubkey"
+            }
+        ]
+    },
+    {
+        name: "drift_update_user_margin_trading_enabled",
+        discriminator: [
+            157,
+            175,
+            12,
+            19,
+            202,
+            114,
+            17,
+            36
+        ],
+        accounts: [
+            {
+                name: "glam_state"
+            },
+            {
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+            },
+            {
+                name: "user",
+                writable: true
+            }
+        ],
+        args: [
+            {
+                name: "sub_account_id",
+                type: "u16"
+            },
+            {
+                name: "margin_trading_enabled",
+                type: "bool"
+            }
+        ]
+    },
+    {
+        name: "drift_vaults_cancel_request_withdraw",
+        discriminator: [
+            241,
+            196,
+            156,
+            180,
+            21,
+            155,
+            228,
+            125
+        ],
+        accounts: [
+            {
+                name: "glam_state"
+            },
+            {
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
+            },
+            {
+                name: "vault",
+                writable: true
+            },
+            {
+                name: "vault_depositor",
+                writable: true
+            },
+            {
+                name: "drift_user_stats"
+            },
+            {
+                name: "drift_user"
+            }
+        ],
+        args: []
+    },
+    {
+        name: "drift_vaults_deposit",
+        discriminator: [
+            95,
+            223,
+            42,
+            76,
+            37,
+            21,
+            176,
+            73
+        ],
+        accounts: [
+            {
+                name: "glam_state"
+            },
+            {
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
+            },
+            {
+                name: "vault",
+                writable: true
+            },
+            {
+                name: "vault_depositor",
+                writable: true
+            },
+            {
+                name: "vault_token_account",
+                writable: true
+            },
+            {
+                name: "drift_user_stats",
+                writable: true
+            },
+            {
+                name: "drift_user",
+                writable: true
+            },
+            {
+                name: "drift_state"
+            },
+            {
+                name: "drift_spot_market_vault",
+                writable: true
+            },
+            {
+                name: "user_token_account",
+                writable: true
+            },
+            {
+                name: "drift_program"
+            },
+            {
+                name: "token_program"
+            }
+        ],
+        args: [
+            {
+                name: "amount",
+                type: "u64"
+            }
+        ]
+    },
+    {
+        name: "drift_vaults_initialize_vault_depositor",
+        discriminator: [
+            109,
+            183,
+            50,
+            62,
+            60,
+            195,
+            192,
+            51
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_vault",
+                writable: true,
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
+            },
+            {
+                name: "vault"
+            },
+            {
+                name: "vault_depositor",
+                writable: true
+            },
+            {
+                name: "rent",
+                address: "SysvarRent111111111111111111111111111111111"
+            },
+            {
+                name: "system_program",
+                address: "11111111111111111111111111111111"
+            }
+        ],
+        args: []
+    },
+    {
+        name: "drift_vaults_request_withdraw",
+        discriminator: [
+            19,
+            53,
+            222,
+            51,
+            44,
+            215,
+            35,
+            82
+        ],
+        accounts: [
+            {
+                name: "glam_state"
+            },
+            {
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
             },
             {
-                name: "user",
+                name: "vault",
+                writable: true
+            },
+            {
+                name: "vault_depositor",
                 writable: true
+            },
+            {
+                name: "drift_user_stats"
+            },
+            {
+                name: "drift_user"
             }
         ],
         args: [
             {
-                name: "sub_account_id",
-                type: "u16"
+                name: "withdraw_amount",
+                type: "u64"
             },
             {
-                name: "delegate",
-                type: "pubkey"
+                name: "withdraw_unit",
+                type: {
+                    defined: {
+                        name: "WithdrawUnit"
+                    }
+                }
             }
         ]
     },
     {
-        name: "drift_update_user_margin_trading_enabled",
+        name: "drift_vaults_withdraw",
         discriminator: [
-            157,
-            175,
-            12,
-            19,
-            202,
-            114,
-            17,
-            36
+            58,
+            127,
+            150,
+            177,
+            66,
+            45,
+            5,
+            30
         ],
         accounts: [
             {
@@ -1586,23 +1944,50 @@ var instructions = [
             },
             {
                 name: "cpi_program",
-                address: "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
             },
             {
-                name: "user",
+                name: "vault",
                 writable: true
-            }
-        ],
-        args: [
+            },
             {
-                name: "sub_account_id",
-                type: "u16"
+                name: "vault_depositor",
+                writable: true
             },
             {
-                name: "margin_trading_enabled",
-                type: "bool"
+                name: "vault_token_account",
+                writable: true
+            },
+            {
+                name: "drift_user_stats",
+                writable: true
+            },
+            {
+                name: "drift_user",
+                writable: true
+            },
+            {
+                name: "drift_state"
+            },
+            {
+                name: "drift_spot_market_vault",
+                writable: true
+            },
+            {
+                name: "drift_signer"
+            },
+            {
+                name: "user_token_account",
+                writable: true
+            },
+            {
+                name: "drift_program"
+            },
+            {
+                name: "token_program"
             }
-        ]
+        ],
+        args: []
     },
     {
         name: "drift_withdraw",
@@ -1772,6 +2157,40 @@ var instructions = [
             }
         ]
     },
+    {
+        name: "extend_state",
+        discriminator: [
+            34,
+            147,
+            151,
+            206,
+            134,
+            128,
+            82,
+            228
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "system_program",
+                address: "11111111111111111111111111111111"
+            }
+        ],
+        args: [
+            {
+                name: "bytes",
+                type: "u32"
+            }
+        ]
+    },
     {
         name: "force_transfer_tokens",
         discriminator: [
@@ -3750,7 +4169,8 @@ var instructions = [
         ],
         accounts: [
             {
-                name: "glam_state"
+                name: "glam_state",
+                writable: true
             },
             {
                 name: "glam_vault",
@@ -3851,25 +4271,118 @@ var instructions = [
         ]
     },
     {
-        name: "marinade_claim",
+        name: "kamino_vaults_deposit",
         discriminator: [
-            54,
-            44,
-            48,
-            204,
-            218,
-            141,
-            36,
-            5
+            209,
+            133,
+            37,
+            193,
+            192,
+            217,
+            55,
+            40
         ],
         accounts: [
             {
-                name: "glam_state",
-                writable: true
+                name: "glam_state"
             },
             {
                 name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "glam_signer",
                 writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
+            },
+            {
+                name: "vault_state",
+                writable: true
+            },
+            {
+                name: "token_vault",
+                writable: true
+            },
+            {
+                name: "token_mint"
+            },
+            {
+                name: "base_vault_authority"
+            },
+            {
+                name: "shares_mint",
+                writable: true
+            },
+            {
+                name: "user_token_ata",
+                writable: true
+            },
+            {
+                name: "user_shares_ata",
+                writable: true
+            },
+            {
+                name: "klend_program"
+            },
+            {
+                name: "token_program"
+            },
+            {
+                name: "shares_token_program"
+            },
+            {
+                name: "event_authority"
+            },
+            {
+                name: "program"
+            }
+        ],
+        args: [
+            {
+                name: "amount",
+                type: "u64"
+            }
+        ]
+    },
+    {
+        name: "kamino_vaults_withdraw",
+        discriminator: [
+            82,
+            106,
+            49,
+            86,
+            156,
+            15,
+            87,
+            8
+        ],
+        accounts: [
+            {
+                name: "glam_state"
+            },
+            {
+                name: "glam_vault",
                 pda: {
                     seeds: [
                         {
@@ -3890,35 +4403,101 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
-                writable: true,
-                signer: true
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "cpi_program",
+                address: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
+            },
+            {
+                name: "withdraw_from_available_vault_state",
+                writable: true
+            },
+            {
+                name: "withdraw_from_available_token_vault",
+                writable: true
+            },
+            {
+                name: "withdraw_from_available_base_vault_authority"
+            },
+            {
+                name: "withdraw_from_available_user_token_ata",
+                writable: true
+            },
+            {
+                name: "withdraw_from_available_token_mint",
+                writable: true
+            },
+            {
+                name: "withdraw_from_available_user_shares_ata",
+                writable: true
+            },
+            {
+                name: "withdraw_from_available_shares_mint",
+                writable: true
+            },
+            {
+                name: "withdraw_from_available_token_program"
+            },
+            {
+                name: "withdraw_from_available_shares_token_program"
+            },
+            {
+                name: "withdraw_from_available_klend_program"
+            },
+            {
+                name: "withdraw_from_available_event_authority"
+            },
+            {
+                name: "withdraw_from_available_program"
+            },
+            {
+                name: "withdraw_from_reserve_vault_state",
+                writable: true
+            },
+            {
+                name: "withdraw_from_reserve_reserve",
+                writable: true
+            },
+            {
+                name: "withdraw_from_reserve_ctoken_vault",
+                writable: true
+            },
+            {
+                name: "withdraw_from_reserve_lending_market"
             },
             {
-                name: "cpi_program",
-                address: "MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD"
+                name: "withdraw_from_reserve_lending_market_authority"
             },
             {
-                name: "state",
+                name: "withdraw_from_reserve_reserve_liquidity_supply",
                 writable: true
             },
             {
-                name: "reserve_pda",
+                name: "withdraw_from_reserve_reserve_collateral_mint",
                 writable: true
             },
             {
-                name: "ticket_account",
-                writable: true
+                name: "withdraw_from_reserve_reserve_collateral_token_program"
             },
             {
-                name: "clock"
+                name: "withdraw_from_reserve_instruction_sysvar_account"
             },
             {
-                name: "system_program",
-                address: "11111111111111111111111111111111"
+                name: "event_authority"
+            },
+            {
+                name: "program"
             }
         ],
-        args: []
+        args: [
+            {
+                name: "amount",
+                type: "u64"
+            }
+        ]
     },
     {
         name: "marinade_deposit",
@@ -4117,88 +4696,6 @@ var instructions = [
             }
         ]
     },
-    {
-        name: "marinade_order_unstake",
-        discriminator: [
-            202,
-            3,
-            33,
-            27,
-            183,
-            156,
-            57,
-            231
-        ],
-        accounts: [
-            {
-                name: "glam_state",
-                writable: true
-            },
-            {
-                name: "glam_vault",
-                writable: true,
-                pda: {
-                    seeds: [
-                        {
-                            kind: "const",
-                            value: [
-                                118,
-                                97,
-                                117,
-                                108,
-                                116
-                            ]
-                        },
-                        {
-                            kind: "account",
-                            path: "glam_state"
-                        }
-                    ]
-                }
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            },
-            {
-                name: "cpi_program",
-                address: "MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD"
-            },
-            {
-                name: "state",
-                writable: true
-            },
-            {
-                name: "msol_mint",
-                writable: true
-            },
-            {
-                name: "burn_msol_from",
-                writable: true
-            },
-            {
-                name: "new_ticket_account",
-                writable: true
-            },
-            {
-                name: "clock"
-            },
-            {
-                name: "rent",
-                address: "SysvarRent111111111111111111111111111111111"
-            },
-            {
-                name: "token_program"
-            }
-        ],
-        args: [
-            {
-                name: "msol_amount",
-                type: "u64"
-            }
-        ]
-    },
     {
         name: "marinade_withdraw_stake_account",
         discriminator: [
@@ -5786,16 +6283,16 @@ var instructions = [
         ]
     },
     {
-        name: "price_drift",
+        name: "price_drift_users",
         discriminator: [
-            240,
-            91,
-            209,
-            89,
-            155,
-            0,
-            97,
-            133
+            12,
+            5,
+            143,
+            51,
+            101,
+            81,
+            200,
+            150
         ],
         accounts: [
             {
@@ -5803,7 +6300,25 @@ var instructions = [
                 writable: true
             },
             {
-                name: "glam_vault"
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
             },
             {
                 name: "signer",
@@ -5814,13 +6329,66 @@ var instructions = [
                 name: "sol_oracle"
             },
             {
-                name: "state"
-            },
-            {
-                name: "user"
-            },
-            {
-                name: "user_stats"
+                name: "glam_config",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                103,
+                                108,
+                                111,
+                                98,
+                                97,
+                                108,
+                                95,
+                                99,
+                                111,
+                                110,
+                                102,
+                                105,
+                                103
+                            ]
+                        }
+                    ],
+                    program: {
+                        kind: "const",
+                        value: [
+                            10,
+                            11,
+                            0,
+                            83,
+                            72,
+                            16,
+                            46,
+                            144,
+                            46,
+                            42,
+                            79,
+                            22,
+                            157,
+                            123,
+                            21,
+                            242,
+                            192,
+                            146,
+                            1,
+                            78,
+                            88,
+                            59,
+                            102,
+                            9,
+                            190,
+                            226,
+                            92,
+                            189,
+                            187,
+                            232,
+                            83,
+                            220
+                        ]
+                    }
+                }
             }
         ],
         args: [
@@ -5835,16 +6403,16 @@ var instructions = [
         ]
     },
     {
-        name: "price_kamino_obligations",
+        name: "price_drift_vault_depositors",
         discriminator: [
-            166,
-            110,
             234,
-            179,
-            240,
-            179,
-            69,
-            246
+            16,
+            238,
+            70,
+            189,
+            23,
+            98,
+            160
         ],
         accounts: [
             {
@@ -5873,14 +6441,10 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
-            {
-                name: "kamino_lending_program",
-                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
-            },
             {
                 name: "sol_oracle"
             },
@@ -5945,22 +6509,6 @@ var instructions = [
                         ]
                     }
                 }
-            },
-            {
-                name: "pyth_oracle",
-                optional: true
-            },
-            {
-                name: "switchboard_price_oracle",
-                optional: true
-            },
-            {
-                name: "switchboard_twap_oracle",
-                optional: true
-            },
-            {
-                name: "scope_prices",
-                optional: true
             }
         ],
         args: [
@@ -5975,16 +6523,16 @@ var instructions = [
         ]
     },
     {
-        name: "price_meteora_positions",
+        name: "price_kamino_obligations",
         discriminator: [
-            186,
-            22,
-            157,
-            249,
-            185,
-            176,
-            253,
-            133
+            166,
+            110,
+            234,
+            179,
+            240,
+            179,
+            69,
+            246
         ],
         accounts: [
             {
@@ -6013,10 +6561,14 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
+            {
+                name: "kamino_lending_program",
+                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+            },
             {
                 name: "sol_oracle"
             },
@@ -6081,6 +6633,22 @@ var instructions = [
                         ]
                     }
                 }
+            },
+            {
+                name: "pyth_oracle",
+                optional: true
+            },
+            {
+                name: "switchboard_price_oracle",
+                optional: true
+            },
+            {
+                name: "switchboard_twap_oracle",
+                optional: true
+            },
+            {
+                name: "scope_prices",
+                optional: true
             }
         ],
         args: [
@@ -6095,16 +6663,16 @@ var instructions = [
         ]
     },
     {
-        name: "price_stakes",
+        name: "price_meteora_positions",
         discriminator: [
-            0,
-            60,
-            60,
-            103,
-            201,
-            94,
-            72,
-            223
+            186,
+            22,
+            157,
+            249,
+            185,
+            176,
+            253,
+            133
         ],
         accounts: [
             {
@@ -6133,7 +6701,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -6215,16 +6783,16 @@ var instructions = [
         ]
     },
     {
-        name: "price_tickets",
+        name: "price_stakes",
         discriminator: [
-            253,
-            18,
-            224,
-            98,
-            226,
-            43,
-            65,
-            76
+            0,
+            60,
+            60,
+            103,
+            201,
+            94,
+            72,
+            223
         ],
         accounts: [
             {
@@ -6253,7 +6821,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -6373,7 +6941,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -9512,11 +10080,6 @@ var errors = [
         name: "InvalidAuthority",
         msg: "Invalid authority"
     },
-    {
-        code: 48009,
-        name: "InvalidPriceDenom",
-        msg: "Invalid price denom"
-    },
     {
         code: 49000,
         name: "InvalidAccountType",
@@ -9717,6 +10280,26 @@ var errors = [
         name: "BaseAssetNotSupported",
         msg: "Base asset must have 6 decimals."
     },
+    {
+        code: 51110,
+        name: "InvalidQuoteSpotMarket",
+        msg: "Unsupported spot market for perp quotes"
+    },
+    {
+        code: 51111,
+        name: "UnknownExternalVaultAsset",
+        msg: "Unknown external vault account"
+    },
+    {
+        code: 51112,
+        name: "InvalidPriceDenom",
+        msg: "Invalid price denom"
+    },
+    {
+        code: 51113,
+        name: "UnexpectedDiscriminator",
+        msg: "Invalid account: discriminator mismatch"
+    },
     {
         code: 52000,
         name: "TransfersDisabled",
@@ -11048,6 +11631,12 @@ var types = [
                 },
                 {
                     name: "MeteoraDlmm"
+                },
+                {
+                    name: "DriftVaults"
+                },
+                {
+                    name: "KaminoVaults"
                 }
             ]
         }
@@ -12168,6 +12757,18 @@ var types = [
                 },
                 {
                     name: "EmergencyUpdate"
+                },
+                {
+                    name: "DriftVaultsDeposit"
+                },
+                {
+                    name: "DriftVaultsWithdraw"
+                },
+                {
+                    name: "KaminoVaultsDeposit"
+                },
+                {
+                    name: "KaminoVaultsWithdraw"
                 }
             ]
         }
@@ -13024,6 +13625,23 @@ var types = [
                 }
             ]
         }
+    },
+    {
+        name: "WithdrawUnit",
+        type: {
+            kind: "enum",
+            variants: [
+                {
+                    name: "Shares"
+                },
+                {
+                    name: "Token"
+                },
+                {
+                    name: "SharesPercent"
+                }
+            ]
+        }
     }
 ];
 var constants = [
@@ -13090,10 +13708,10 @@ const SEED_MINT = (GlamProtocolIdlJson.constants.find((x)=>x.name === "SEED_MINT
 const SEED_STATE = (GlamProtocolIdlJson.constants.find((x)=>x.name === "SEED_STATE")?.value || "").replace(/"/g, "");
 const SEED_VAULT = (GlamProtocolIdlJson.constants.find((x)=>x.name === "SEED_VAULT")?.value || "").replace(/"/g, "");
 const SEED_ESCROW = (GlamProtocolIdlJson.constants.find((x)=>x.name === "SEED_ESCROW")?.value || "").replace(/"/g, "");
-const MARINADE_TICKET_SIZE = 88;
 const STAKE_ACCOUNT_SIZE = 200;
 const METEORA_POSITION_SIZE = 8120;
 const KAMINO_OBTRIGATION_SIZE = 3344;
+const DRIFT_VAULT_DEPOSITOR_SIZE = 272;
 const JITO_TIP_DEFAULT = new web3_js.PublicKey("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5");
 const KAMINO_SCOPE_PRICES = new web3_js.PublicKey("3NJYftD5sjVfxSnUdZ1wVML8f3aC6mp1CXCL6L7TnU8C");
 const MARINADE_NATIVE_STAKE_AUTHORITY = new web3_js.PublicKey("stWirqFCf2Uts1JBL1Jsd3r6VBWhgnpdPxCTe1MFjrq");
@@ -13111,6 +13729,7 @@ const JUP = new web3_js.PublicKey("JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN")
  * Program IDs
  */ const MARINADE_PROGRAM_ID = new web3_js.PublicKey("MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD");
 const DRIFT_PROGRAM_ID = new web3_js.PublicKey("dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH");
+const DRIFT_VAULTS_PROGRAM_ID = new web3_js.PublicKey("vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR");
 const JUPITER_PROGRAM_ID = new web3_js.PublicKey("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4");
 const SANCTUM_STAKE_POOL_PROGRAM_ID = new web3_js.PublicKey("SP12tWFxD9oJsVWNavTTBZvMbA6gkAmxtVgxdqvyvhY");
 const GOVERNANCE_PROGRAM_ID = new web3_js.PublicKey("GovaE4iu227srtG2s3tZzB4RmWBzw8sTwrCLZz7kN7rY");
@@ -13519,7 +14138,7 @@ var ClusterNetwork = /*#__PURE__*/ function(ClusterNetwork) {
     return ClusterNetwork;
 }({});
 
-const fetchStakeAccounts = async (connection, withdrawAuthority)=>{
+const findStakeAccounts = async (connection, withdrawAuthority)=>{
     // stake authority offset: 12
     // withdraw authority offset: 44
     const accounts = await connection.getParsedProgramAccounts(web3_js.StakeProgram.programId, {
@@ -13586,43 +14205,6 @@ const getStakeAccountsWithStates = async (connection, withdrawAuthority)=>{
     // order by lamports desc
     return stakes.sort((a, b)=>b.lamports - a.lamports);
 };
-const fetchMarinadeTicketAccounts = async (connection, beneficiary)=>await connection.getProgramAccounts(MARINADE_PROGRAM_ID, {
-        filters: [
-            {
-                dataSize: MARINADE_TICKET_SIZE
-            },
-            {
-                memcmp: {
-                    offset: 40,
-                    bytes: beneficiary.toBase58()
-                }
-            }
-        ]
-    });
-const fetchKaminoObligations = async (connection, owner, market)=>{
-    const accounts = await connection.getProgramAccounts(KAMINO_LENDING_PROGRAM, {
-        filters: [
-            {
-                dataSize: KAMINO_OBTRIGATION_SIZE
-            },
-            {
-                memcmp: {
-                    offset: 64,
-                    bytes: owner.toBase58()
-                }
-            },
-            ...market ? [
-                {
-                    memcmp: {
-                        offset: 32,
-                        bytes: market.toBase58()
-                    }
-                }
-            ] : []
-        ]
-    });
-    return accounts.map((a)=>a.pubkey);
-};
 const fetchMeteoraPositions = async (connection, owner)=>{
     const accounts = await connection.getProgramAccounts(METEORA_DLMM_PROGRAM, {
         filters: [
@@ -13679,6 +14261,22 @@ async function fetchLookupTables(connection, authority, firstEntry) {
     // );
     return [];
 }
+/**
+ * Parses program logs to extract error message
+ */ function parseProgramLogs(logs) {
+    // "Error Message:" indicates an anchor program error
+    // Other messages are manually sourced & handled
+    const errorMsgLog = (logs || []).find((log)=>log.includes("Error Message:") || log.includes("Error: insufficient funds"));
+    console.log("error message found in program logs", errorMsgLog);
+    if (errorMsgLog) {
+        if (errorMsgLog.includes("Error Message:")) {
+            return errorMsgLog.split("Error Message:")[1].trim();
+        } else {
+            return "Insufficient funds";
+        }
+    }
+    return "Unknown error";
+}
 const getSimulationComputeUnits = async (connection, instructions, payer, lookupTables)=>{
     const testInstructions = [
         // Set an arbitrarily high number in simulation
@@ -13726,12 +14324,15 @@ const getErrorFromRPCResponse = (rpcResponse)=>{
                 const customErrorCode = instructionError[1]["Custom"];
                 const { errors: glamErrors } = GlamProtocolIdlJson;
                 const glamError = glamErrors.find((e)=>e.code === customErrorCode);
-                const msg = glamError?.msg || "Unknown custsom error";
-                console.log(`Custom error code: ${customErrorCode}, error: ${msg}}`);
-                throw new Error(msg);
+                if (glamError?.msg) {
+                    throw new Error(glamError.msg);
+                }
+                // Unrecognized error code, try to parse program logs to get error message
+                const errMsg = parseProgramLogs(rpcResponse.value.logs);
+                throw new Error(errMsg);
             }
         }
-        throw Error(error.toString());
+        throw Error("Unknown error");
     }
 };
 const setsAreEqual = (a, b)=>{
@@ -13743,14 +14344,19 @@ const setsAreEqual = (a, b)=>{
 };
 
 const STAKE_POOLS = sanctumLstList.LstList.filter((lst)=>!lst.name.includes("Sanctum Automated") && (lst.pool.program === "Spl" || lst.pool.program === "Marinade" || lst.pool.program === "SanctumSpl" || lst.pool.program === "SanctumSplMulti")).map((lst)=>{
-    const { pool, tokenProgram } = lst.pool;
+    const { pool, program } = lst.pool;
+    const poolState = program === "Marinade" ? "8szGkuLTAux9XMgZ2vtY39jVSowEcpBfFfD8hXSEqdGC" : pool;
+    if (!poolState) {
+        throw new Error("Invalid pool state for LST: " + lst.name);
+    }
     return {
         name: lst.name,
         symbol: lst.symbol,
         mint: lst.mint,
+        decimals: lst.decimals,
         logoURI: lst.logoUri,
-        tokenProgram,
-        poolState: lst.pool.program === "Marinade" ? "8szGkuLTAux9XMgZ2vtY39jVSowEcpBfFfD8hXSEqdGC" : pool || ""
+        tokenProgram: new web3_js.PublicKey(lst.tokenProgram),
+        poolState: new web3_js.PublicKey(poolState)
     };
 });
 const STAKE_POOLS_MAP = new Map(STAKE_POOLS.map((p)=>[
@@ -13901,6 +14507,7 @@ const ASSETS_MAINNET = new Map([
 ]);
 const ASSETS_TESTS = new Map([]);
 const SOL_ORACLE = ASSETS_MAINNET.get("So11111111111111111111111111111111111111112").oracle;
+const USDC_ORACLE = ASSETS_MAINNET.get("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v").oracle;
 
 class GlamError extends Error {
     constructor(message, rawError, programLogs){
@@ -14221,18 +14828,10 @@ class BaseClient {
             const errTx = await connection.getTransaction(txSig, {
                 maxSupportedTransactionVersion: 0
             });
-            throw new GlamError(this.parseProgramLogs(errTx?.meta?.logMessages), errTx?.meta?.err || undefined, errTx?.meta?.logMessages || []);
+            throw new GlamError(parseProgramLogs(errTx?.meta?.logMessages), errTx?.meta?.err || undefined, errTx?.meta?.logMessages || []);
         }
         return txSig;
     }
-    parseProgramLogs(logs) {
-        const errorMsgLog = (logs || []).find((log)=>log.includes("Error Message:"));
-        console.log("error message from program logs", errorMsgLog);
-        if (errorMsgLog) {
-            return errorMsgLog.split("Error Message:")[1].trim();
-        }
-        return "Unknown error";
-    }
     async getAdressLookupTableAccounts(keys) {
         if (!keys) {
             throw new Error("addressLookupTableAddresses is undefined");
@@ -15107,6 +15706,64 @@ SwapReduceOnly.Out = {
     out: {}
 };
 
+const DriftVaultLayout = borsh.struct([
+    borsh.array(borsh.u8(), 8, "discriminator"),
+    // Basic vault info
+    borsh.array(borsh.u8(), 32, "name"),
+    borsh.publicKey("pubkey"),
+    borsh.publicKey("manager"),
+    borsh.publicKey("tokenAccount"),
+    borsh.publicKey("userStats"),
+    borsh.publicKey("user"),
+    borsh.publicKey("delegate"),
+    borsh.publicKey("liquidationDelegate"),
+    // Share accounting
+    borsh.u128("userShares"),
+    borsh.u128("totalShares"),
+    // Timestamps
+    borsh.i64("lastFeeUpdateTs"),
+    borsh.i64("liquidationStartTs"),
+    borsh.i64("redeemPeriod"),
+    // Withdrawal tracking
+    borsh.u64("totalWithdrawRequested"),
+    // Capacity and fees
+    borsh.u64("maxTokens"),
+    borsh.i64("managementFee"),
+    borsh.i64("initTs"),
+    // Deposit/withdrawal accounting
+    borsh.i64("netDeposits"),
+    borsh.i64("managerNetDeposits"),
+    borsh.u64("totalDeposits"),
+    borsh.u64("totalWithdraws"),
+    borsh.u64("managerTotalDeposits"),
+    borsh.u64("managerTotalWithdraws"),
+    borsh.i64("managerTotalFee"),
+    borsh.i64("managerTotalProfitShare"),
+    borsh.u64("minDepositAmount"),
+    // Manager withdraw request
+    borsh.struct([
+        borsh.u128("shares"),
+        borsh.u64("amount"),
+        borsh.i64("ts")
+    ], "lastManagerWithdrawRequest"),
+    // Configuration
+    borsh.u32("sharesBase"),
+    borsh.u32("profitShare"),
+    borsh.u32("hurdleRate"),
+    borsh.u16("spotMarketIndex"),
+    borsh.u8("bump"),
+    borsh.bool("permissioned"),
+    borsh.bool("vaultProtocol"),
+    borsh.u8("fuelDistributionMode"),
+    borsh.u8("feeUpdateStatus"),
+    borsh.u8("padding1"),
+    borsh.u32("lastCumulativeFuelPerShareTs"),
+    borsh.u128("cumulativeFuelPerShare"),
+    borsh.u128("cumulativeFuel"),
+    // Final padding
+    borsh.array(borsh.u64(), 3, "padding")
+]);
+
 function readUnsignedBigInt64LE(buffer, offset) {
     return new anchor.BN(buffer.subarray(offset, offset + 8), 10, "le");
 }
@@ -15590,8 +16247,14 @@ class DriftClient {
                 }
             });
         }
-        // At this point this.spotMarkets has all the requested markets
-        return marketIndexes.map((marketIndex)=>this.spotMarkets.get(marketIndex)).filter((m)=>m);
+        // At this point this.spotMarkets should have all the requested markets
+        // If not, it means some market indexes are invalid and we throw an error
+        const spotMarkets = marketIndexes.map((marketIndex)=>this.spotMarkets.get(marketIndex)).filter((m)=>m);
+        const invalidIndexes = marketIndexes.filter((marketIndex)=>!this.spotMarkets.has(marketIndex));
+        if (invalidIndexes.length > 0) {
+            console.warn(`The following spot markets could not be found: ${invalidIndexes.join(", ")}`);
+        }
+        return spotMarkets;
     }
     async fetchAndParsePerpMarket(marketIndex) {
         const markets = await this.fetchAndParsePerpMarkets([
@@ -15621,7 +16284,12 @@ class DriftClient {
                 console.log("Requested perp markets already cached:", marketIndexes);
             }
         }
-        return marketIndexes.map((marketIndex)=>this.perpMarkets.get(marketIndex)).filter((m)=>m);
+        const perpMarkets = marketIndexes.map((marketIndex)=>this.perpMarkets.get(marketIndex)).filter((m)=>m);
+        const invalidIndexes = marketIndexes.filter((marketIndex)=>!this.perpMarkets.has(marketIndex));
+        if (invalidIndexes.length > 0) {
+            console.warn(`The following perp markets could not be found: ${invalidIndexes.join(", ")}`);
+        }
+        return perpMarkets;
     }
     async fetchMarketConfigs() {
         // const response = await fetch(
@@ -16039,47 +16707,231 @@ class DriftClient {
         const tx = await this.base.program.methods.driftCancelOrdersByIds(orderIds).accounts({
             glamState: this.base.statePda,
             glamSigner,
-            user,
-            state: this.driftStatePda
+            user,
+            state: this.driftStatePda
+        }).remainingAccounts(remainingAccounts).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    async settlePnlTx(marketIndex, subAccountId = 0, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const { user } = this.getDriftUserPdas(subAccountId);
+        const { vault: driftVault } = await this.fetchAndParseSpotMarket(0);
+        const remainingAccounts = await this.composeRemainingAccounts(subAccountId, MarketType.PERP, marketIndex);
+        // @ts-ignore
+        const tx = await this.base.program.methods.driftSettlePnl(marketIndex).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            user,
+            state: this.driftStatePda,
+            spotMarketVault: driftVault
+        }).remainingAccounts(remainingAccounts).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    constructor(base){
+        this.base = base;
+        this.spotMarkets = new Map();
+        this.perpMarkets = new Map();
+        this.marketConfigs = null;
+        this./*
+   * Utils
+   */ getMarketPda = (marketType, marketIndex)=>web3_js.PublicKey.findProgramAddressSync([
+                Buffer.from(`${marketType === MarketType.PERP ? "perp" : "spot"}_market`),
+                new anchor__namespace.BN(marketIndex).toArrayLike(Buffer, "le", 2)
+            ], DRIFT_PROGRAM_ID)[0];
+        this.getUserPda = (authority, subAccountId = 0)=>web3_js.PublicKey.findProgramAddressSync([
+                Buffer.from("user"),
+                authority.toBuffer(),
+                new anchor__namespace.BN(subAccountId).toArrayLike(Buffer, "le", 2)
+            ], DRIFT_PROGRAM_ID)[0];
+        this.getUserStatsPda = (authority)=>web3_js.PublicKey.findProgramAddressSync([
+                Buffer.from("user_stats"),
+                authority.toBuffer()
+            ], DRIFT_PROGRAM_ID)[0];
+        this.marketTypeEquals = (a, b)=>a && Object.keys(a)[0] === Object.keys(b)[0];
+    }
+}
+class DriftVaultsClient {
+    async fetchUserPositions(user) {
+        const accountInfo = await this.base.provider.connection.getAccountInfo(user);
+        if (!accountInfo) {
+            throw new Error(`Drift user ${user} account not found for vault.`);
+        }
+        const { spotPositions, perpPositions } = decodeUser(accountInfo.data);
+        return {
+            perpPositions,
+            spotPositions
+        };
+    }
+    getDepositorPda(driftVault) {
+        return web3_js.PublicKey.findProgramAddressSync([
+            Buffer.from("vault_depositor"),
+            driftVault.toBuffer(),
+            this.base.vaultPda.toBuffer()
+        ], DRIFT_VAULTS_PROGRAM_ID)[0];
+    }
+    async parseDriftVault(driftVault) {
+        const connection = this.base.provider.connection;
+        const accountInfo = await connection.getAccountInfo(driftVault);
+        if (!accountInfo) {
+            throw new Error(`Drift vault account not found: ${driftVault.toBase58()}`);
+        }
+        try {
+            return DriftVaultLayout.decode(accountInfo.data);
+        } catch (error) {
+            throw new Error(`Failed to parse drift vault account: ${error}`);
+        }
+    }
+    async composeRemainingAccounts(user) {
+        const { spotPositions, perpPositions } = await this.fetchUserPositions(user);
+        const spotMarketIndexes = spotPositions.map((p)=>p.marketIndex);
+        const perpMarketIndexes = perpPositions.map((p)=>p.marketIndex);
+        // If there are perp positions, add spot market 0 as it's used as quote market for perp
+        if (perpMarketIndexes.length > 0 && !spotMarketIndexes.includes(0)) {
+            spotMarketIndexes.push(0);
+        }
+        const spotMarkets = await this.drift.fetchAndParseSpotMarkets(spotMarketIndexes);
+        const perpMarkets = await this.drift.fetchAndParsePerpMarkets(perpMarketIndexes);
+        const oracles = spotMarkets.map((m)=>m.oracle).concat(perpMarkets.map((m)=>m.oracle));
+        const markets = spotMarkets.map((m)=>m.marketPda).concat(perpMarkets.map((m)=>m.marketPda));
+        return oracles.map((o)=>({
+                pubkey: new web3_js.PublicKey(o),
+                isWritable: false,
+                isSigner: false
+            })).concat(markets.map((m)=>({
+                pubkey: new web3_js.PublicKey(m),
+                isWritable: true,
+                isSigner: false
+            })));
+    }
+    parseDepositor(depositor, data) {
+        const driftVault = new web3_js.PublicKey(data.subarray(8, 40));
+        const shares = new anchor.BN(data.subarray(104, 112), "le");
+        return {
+            address: depositor,
+            driftVault,
+            shares
+        };
+    }
+    /**
+   * Finds all drift vault depositors
+   */ async findAndParseVaultDepositors(authority) {
+        const accounts = await this.base.provider.connection.getProgramAccounts(DRIFT_VAULTS_PROGRAM_ID, {
+            filters: [
+                {
+                    dataSize: DRIFT_VAULT_DEPOSITOR_SIZE
+                },
+                {
+                    memcmp: {
+                        offset: 72,
+                        bytes: (authority || this.base.vaultPda).toBase58()
+                    }
+                }
+            ]
+        });
+        return accounts.map((a)=>this.parseDepositor(a.pubkey, a.account.data));
+    }
+    async initializeVaultDepositor(driftVault, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultDepositor = this.getDepositorPda(driftVault);
+        const tx = await this.base.program.methods.driftVaultsInitializeVaultDepositor().accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            vault: driftVault,
+            vaultDepositor
+        }).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async deposit(driftVault, amount, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultDepositor = this.getDepositorPda(driftVault);
+        const { user: driftUser, tokenAccount: vaultTokenAccount, userStats: driftUserStats, spotMarketIndex, vaultProtocol } = await this.parseDriftVault(driftVault);
+        if (vaultProtocol) {
+            throw new Error("Vault protocol fees not supported");
+        }
+        const { vault: driftSpotMarketVault, mint, tokenProgram } = await this.drift.fetchAndParseSpotMarket(spotMarketIndex);
+        const remainingAccounts = await this.composeRemainingAccounts(driftUser);
+        // GLAM vault's token account for deposit, we assume it exists
+        const userTokenAccount = this.base.getVaultAta(mint, tokenProgram);
+        const tx = await this.base.program.methods.driftVaultsDeposit(amount).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            vault: driftVault,
+            vaultDepositor,
+            vaultTokenAccount,
+            driftUserStats,
+            driftUser,
+            driftState: this.drift.driftStatePda,
+            driftSpotMarketVault,
+            userTokenAccount,
+            tokenProgram,
+            driftProgram: DRIFT_PROGRAM_ID
+        }).remainingAccounts(remainingAccounts).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async requestWithdraw(driftVault, amount, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultDepositor = this.getDepositorPda(driftVault);
+        const { user: driftUser, userStats: driftUserStats } = await this.parseDriftVault(driftVault);
+        const remainingAccounts = await this.composeRemainingAccounts(driftUser);
+        const tx = await this.base.program.methods.driftVaultsRequestWithdraw(amount, {
+            shares: {}
+        }).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            vault: driftVault,
+            vaultDepositor,
+            driftUserStats,
+            driftUser
+        }).remainingAccounts(remainingAccounts).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async cancelWithdrawRequest(driftVault, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultDepositor = this.getDepositorPda(driftVault);
+        const { user: driftUser, userStats: driftUserStats } = await this.parseDriftVault(driftVault);
+        const remainingAccounts = await this.composeRemainingAccounts(driftUser);
+        const tx = await this.base.program.methods.driftVaultsCancelRequestWithdraw().accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            vault: driftVault,
+            vaultDepositor,
+            driftUserStats,
+            driftUser
         }).remainingAccounts(remainingAccounts).transaction();
-        return await this.base.intoVersionedTransaction(tx, txOptions);
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
     }
-    async settlePnlTx(marketIndex, subAccountId = 0, txOptions = {}) {
+    async withdraw(driftVault, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(subAccountId);
-        const { vault: driftVault } = await this.fetchAndParseSpotMarket(0);
-        const remainingAccounts = await this.composeRemainingAccounts(subAccountId, MarketType.PERP, marketIndex);
-        // @ts-ignore
-        const tx = await this.base.program.methods.driftSettlePnl(marketIndex).accounts({
+        const vaultDepositor = this.getDepositorPda(driftVault);
+        const { user: driftUser, userStats: driftUserStats, tokenAccount: vaultTokenAccount, spotMarketIndex } = await this.parseDriftVault(driftVault);
+        const { vault: driftSpotMarketVault, mint, tokenProgram } = await this.drift.fetchAndParseSpotMarket(spotMarketIndex);
+        const userTokenAccount = this.base.getVaultAta(mint, tokenProgram);
+        const remainingAccounts = await this.composeRemainingAccounts(driftUser);
+        const tx = await this.base.program.methods.driftVaultsWithdraw().accounts({
             glamState: this.base.statePda,
             glamSigner,
-            user,
-            state: this.driftStatePda,
-            spotMarketVault: driftVault
+            vault: driftVault,
+            vaultDepositor,
+            vaultTokenAccount,
+            driftUserStats,
+            driftUser,
+            driftSpotMarketVault,
+            driftSigner: DRIFT_SIGNER,
+            userTokenAccount,
+            driftState: this.drift.driftStatePda,
+            driftProgram: DRIFT_PROGRAM_ID,
+            tokenProgram
         }).remainingAccounts(remainingAccounts).transaction();
-        return await this.base.intoVersionedTransaction(tx, txOptions);
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
     }
-    constructor(base){
+    constructor(base, drift){
         this.base = base;
-        this.spotMarkets = new Map();
-        this.perpMarkets = new Map();
-        this.marketConfigs = null;
-        this./*
-   * Utils
-   */ getMarketPda = (marketType, marketIndex)=>web3_js.PublicKey.findProgramAddressSync([
-                Buffer.from(`${marketType === MarketType.PERP ? "perp" : "spot"}_market`),
-                new anchor__namespace.BN(marketIndex).toArrayLike(Buffer, "le", 2)
-            ], DRIFT_PROGRAM_ID)[0];
-        this.getUserPda = (authority, subAccountId = 0)=>web3_js.PublicKey.findProgramAddressSync([
-                Buffer.from("user"),
-                authority.toBuffer(),
-                new anchor__namespace.BN(subAccountId).toArrayLike(Buffer, "le", 2)
-            ], DRIFT_PROGRAM_ID)[0];
-        this.getUserStatsPda = (authority)=>web3_js.PublicKey.findProgramAddressSync([
-                Buffer.from("user_stats"),
-                authority.toBuffer()
-            ], DRIFT_PROGRAM_ID)[0];
-        this.marketTypeEquals = (a, b)=>a && Object.keys(a)[0] === Object.keys(b)[0];
+        this.drift = drift;
     }
 }
 
@@ -16153,8 +17005,8 @@ class JupiterSwapClient {
             this.getTokenProgram(inputMint),
             this.getTokenProgram(outputMint)
         ]);
-        const inputStakePool = ASSETS_MAINNET.get(inputMint.toBase58())?.oracle || null;
-        const outputStakePool = ASSETS_MAINNET.get(outputMint.toBase58())?.oracle || null;
+        const inputStakePool = STAKE_POOLS_MAP.get(inputMint.toBase58())?.poolState || null;
+        const outputStakePool = STAKE_POOLS_MAP.get(outputMint.toBase58())?.poolState || null;
         const preInstructions = await this.getPreInstructions(glamSigner, inputMint, outputMint, amount, inputTokenProgram, outputTokenProgram);
         // @ts-ignore
         const tx = await this.base.program.methods.jupiterSwap(swapIx.data).accounts({
@@ -16492,45 +17344,15 @@ class MarinadeClient {
         const tx = await this.depositStakeAccountTx(stakeAccount, {});
         return await this.base.sendAndConfirm(tx);
     }
-    async withdrawStakeAccount(amount, txOptions = {}) {
-        const [tx, extraSigner] = await this.withdrawStakeAccountTx(amount, txOptions);
+    async withdrawStakeAccount(amount, deactivate = false, txOptions = {}) {
+        const [tx, extraSigner] = await this.withdrawStakeAccountTx(amount, deactivate, txOptions);
         return await this.base.sendAndConfirm(tx, [
             extraSigner
         ]);
     }
-    async orderUnstake(amount, txOptions = {}) {
-        const tx = await this.orderUnstakeTx(amount, txOptions);
-        return await this.base.sendAndConfirm(tx);
-    }
-    async claim(tickets, txOptions = {}) {
-        const tx = await this.claimTx(tickets, txOptions);
-        return await this.base.sendAndConfirm(tx);
-    }
     /*
    * Utils
-   */ async getTickets() {
-        const vault = this.base.vaultPda;
-        const accounts = await fetchMarinadeTicketAccounts(this.base.provider.connection, vault);
-        return accounts.map((a)=>a.pubkey);
-    }
-    async getParsedTickets() {
-        const vault = this.base.vaultPda;
-        const accounts = await fetchMarinadeTicketAccounts(this.base.provider.connection, vault);
-        const currentEpoch = await this.base.provider.connection.getEpochInfo();
-        return accounts.map((a)=>{
-            const lamports = Number(a.account.data.readBigInt64LE(72));
-            const createdEpoch = Number(a.account.data.readBigInt64LE(80));
-            const isDue = currentEpoch.epoch > createdEpoch;
-            return {
-                address: a.pubkey,
-                lamports,
-                createdEpoch,
-                isDue,
-                isClaimable: isDue && currentEpoch.slotIndex > 5000
-            };
-        });
-    }
-    /**
+   */ /**
    * @deprecated Use Marinade.getMarinadeState() instead
    */ get marinadeStateStatic() {
         // The addresses are the same in mainnet and devnet:
@@ -16692,7 +17514,7 @@ class MarinadeClient {
             validatorIndex
         };
     }
-    async withdrawStakeAccountTx(amount, txOptions) {
+    async withdrawStakeAccountTx(amount, deactivate = false, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const marinadeState = await this.fetchMarinadeState();
         // Get mariande stake withdraw authority
@@ -16706,6 +17528,13 @@ class MarinadeClient {
         const { stakeIndex, validatorIndex } = await this.getIndexes(stakeAccounts[0], stakeList, validatorList);
         const burnMsolFrom = this.base.getVaultAta(MSOL);
         const newStake = web3_js.Keypair.generate();
+        const postInstructions = deactivate ? [
+            await this.base.program.methods.stakeDeactivate().accounts({
+                glamSigner,
+                glamState: this.base.statePda,
+                stake: newStake.publicKey
+            }).instruction()
+        ] : [];
         const tx = await this.base.program.methods.marinadeWithdrawStakeAccount(stakeIndex, validatorIndex, amount, this.base.vaultPda).accounts({
             glamState: this.base.statePda,
             glamSigner,
@@ -16722,61 +17551,13 @@ class MarinadeClient {
             clock: web3_js.SYSVAR_CLOCK_PUBKEY,
             tokenProgram: splToken.TOKEN_PROGRAM_ID,
             stakeProgram: web3_js.StakeProgram.programId
-        }).transaction();
+        }).postInstructions(postInstructions).transaction();
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return [
             vTx,
             newStake
         ];
     }
-    async orderUnstakeTx(amount, txOptions) {
-        const glamSigner = txOptions.signer || this.base.getSigner();
-        const marinadeState = this.marinadeStateStatic;
-        const vaultMsolAta = this.base.getVaultAta(marinadeState.msolMintAddress);
-        const ticketSeed = Date.now().toString();
-        const ticket = await web3_js.PublicKey.createWithSeed(glamSigner, ticketSeed, MARINADE_PROGRAM_ID);
-        const lamports = await this.base.provider.connection.getMinimumBalanceForRentExemption(MARINADE_TICKET_SIZE);
-        const createTicketIx = web3_js.SystemProgram.createAccountWithSeed({
-            fromPubkey: glamSigner,
-            newAccountPubkey: ticket,
-            basePubkey: glamSigner,
-            seed: ticketSeed,
-            lamports,
-            space: MARINADE_TICKET_SIZE,
-            programId: MARINADE_PROGRAM_ID
-        });
-        const tx = await this.base.program.methods.marinadeOrderUnstake(amount).accounts({
-            glamState: this.base.statePda,
-            glamSigner,
-            newTicketAccount: ticket,
-            msolMint: marinadeState.msolMintAddress,
-            burnMsolFrom: vaultMsolAta,
-            state: marinadeState.marinadeStateAddress,
-            clock: web3_js.SYSVAR_CLOCK_PUBKEY,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID
-        }).preInstructions([
-            createTicketIx
-        ]).transaction();
-        return await this.base.intoVersionedTransaction(tx, txOptions);
-    }
-    async claimTx(tickets, txOptions) {
-        if (tickets.length < 1) {
-            throw new Error("At least one ticket is required");
-        }
-        const glamSigner = txOptions.signer || this.base.getSigner();
-        const marinadeState = this.marinadeStateStatic;
-        const instructions = await Promise.all(tickets.map((ticket)=>this.base.program.methods.marinadeClaim().accounts({
-                glamState: this.base.statePda,
-                glamSigner,
-                ticketAccount: ticket,
-                state: marinadeState.marinadeStateAddress,
-                reservePda: marinadeState.reserveAddress,
-                clock: web3_js.SYSVAR_CLOCK_PUBKEY
-            }).instruction()));
-        const tx = new web3_js.Transaction();
-        tx.add(...instructions);
-        return await this.base.intoVersionedTransaction(tx, txOptions);
-    }
     constructor(base){
         this.base = base;
     }
@@ -16968,20 +17749,17 @@ class VaultClient {
 class StakingClient {
     /*
    * Client methods
-   */ async unstake(asset, amount, txOptions = {}) {
-        const assetStr = asset.toBase58();
+   */ async unstake(asset, amount, deactivate = false, txOptions = {}) {
         // mSOL
-        if (assetStr === MSOL.toBase58()) {
-            const tx = await this.marinade.orderUnstakeTx(new anchor.BN(amount), txOptions);
-            return await this.base.sendAndConfirm(tx);
+        if (asset.equals(MSOL)) {
+            return await this.marinade.withdrawStakeAccount(new anchor.BN(amount), deactivate, txOptions);
         }
         // Other LSTs
-        const assetMeta = this.base.getAssetMeta(assetStr);
-        if (!assetMeta || !assetMeta.oracle) {
-            throw new Error("Invalid LST: " + asset);
+        const stakePool = STAKE_POOLS.find((p)=>p.mint === asset.toBase58());
+        if (!stakePool) {
+            throw new Error(`LST not supported: ${asset}`);
         }
-        const tx = await this.stakePoolWithdrawStakeTx(assetMeta.oracle, new anchor.BN(amount), true, txOptions);
-        return await this.base.sendAndConfirm(tx);
+        return await this.stakePoolWithdrawStake(stakePool.poolState, new anchor.BN(amount), deactivate, txOptions);
     }
     async stakePoolDepositSol(stakePool, amount, txOptions = {}) {
         const tx = await this.stakePoolDepositSolTx(stakePool, amount, txOptions);
@@ -16991,8 +17769,8 @@ class StakingClient {
         const tx = await this.stakePoolDepositStakeTx(stakePool, stakeAccount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async stakePoolWithdrawStake(stakePool, amount, txOptions = {}) {
-        const tx = await this.stakePoolWithdrawStakeTx(stakePool, amount, false, txOptions);
+    async stakePoolWithdrawStake(stakePool, amount, deactivate = false, txOptions = {}) {
+        const tx = await this.stakePoolWithdrawStakeTx(stakePool, amount, deactivate, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     async initializeAndDelegateStake(vote, amount, txOptions = {}) {
@@ -17210,11 +17988,9 @@ class StakingClient {
     async stakePoolWithdrawStakeTx(stakePool, amount, deactivate = false, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { programId: stakePoolProgram, poolMint, withdrawAuthority, feeAccount, tokenProgramId: tokenProgram, validatorList, reserveStake } = await this.getStakePoolAccountData(stakePool);
-        this.base.vaultPda;
         const poolTokensFrom = this.base.getVaultAta(poolMint, tokenProgram);
         // The reserve stake account should NOT be used for withdrawals unless we have no other options.
         const validatorStakeCandidates = (await getStakeAccountsWithStates(this.base.provider.connection, withdrawAuthority)).filter((s)=>!s.address.equals(reserveStake));
-        console.log("validatorStakeCandidates", validatorStakeCandidates);
         const validatorStakeAccount = validatorStakeCandidates.length === 0 ? reserveStake : validatorStakeCandidates[0].address;
         const [stakeAccount, createStakeAccountIx] = await this.createStakeAccount(glamSigner);
         const postInstructions = deactivate ? [
@@ -17466,6 +18242,14 @@ class StateClient {
         }).preInstructions(txOptions.preInstructions || []).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
+    async extend(newBytes, txOptions = {}) {
+        const tx = await this.base.program.methods.extendState(newBytes).accounts({
+            glamState: this.base.statePda,
+            glamSigner: this.base.signer
+        }).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
     async close(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.program.methods.closeState().accounts({
@@ -18024,7 +18808,7 @@ function refreshObligationFarmsForReserve(args, accounts, programId = KAMINO_LEN
     const data = Buffer.concat([
         identifier,
         buffer
-    ]).slice(0, 8 + len);
+    ]).subarray(0, 8 + len);
     const ix = new web3_js.TransactionInstruction({
         keys,
         programId,
@@ -18123,21 +18907,6 @@ class KaminoLendingClient {
         ], KAMINO_FARM_PROGRAM);
         return obligationFarm;
     }
-    async initUserMetadataTx(txOptions = {}) {
-        const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.vaultPda;
-        const userMetadata = this.getUserMetadataPda(vault);
-        const lookupTable = new web3_js.PublicKey(0); // FIXME: create lookup table
-        // @ts-ignore
-        const tx = await this.base.program.methods.kaminoLendingInitUserMetadata(lookupTable).accounts({
-            glamState: this.base.statePda,
-            glamSigner,
-            userMetadata,
-            referrerUserMetadata: null
-        }).transaction();
-        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
-        return vTx;
-    }
     refreshReserveIxs(lendingMarket, reserves) {
         return reserves.map((reserve)=>refreshReserve({
                 reserve,
@@ -18235,26 +19004,7 @@ class KaminoLendingClient {
             feeVault
         };
     }
-    /**
-   * Fetches and parses obligation account
-   *
-   * @param obligation User obligation pubkey
-   * @returns Pubkeys of reserves for deposits and borrows
-   */ async fetchAndParseObligation(obligation) {
-        const cached = this.obligations.get(obligation);
-        if (cached) {
-            return cached;
-        }
-        const obligationAccount = await this.base.provider.connection.getAccountInfo(obligation);
-        if (!obligationAccount) {
-            return {
-                address: obligation,
-                lendingMarket: null,
-                deposits: [],
-                borrows: []
-            };
-        }
-        const data = obligationAccount.data;
+    parseObligation(obligation, data) {
         const lendingMarket = new web3_js.PublicKey(data.subarray(32, 64));
         // read deposits
         let depositsOffset = 96;
@@ -18284,21 +19034,40 @@ class KaminoLendingClient {
                 reserve
             };
         }).filter((d)=>!d.reserve.equals(web3_js.PublicKey.default));
-        const parsedObligation = {
+        return {
             address: obligation,
             lendingMarket,
             deposits,
             borrows
         };
+    }
+    /**
+   * Fetches and parses an obligation account
+   */ async fetchAndParseObligation(obligation) {
+        const cached = this.obligations.get(obligation);
+        if (cached) {
+            return cached;
+        }
+        const obligationAccount = await this.base.provider.connection.getAccountInfo(obligation);
+        if (!obligationAccount) {
+            return {
+                address: obligation,
+                lendingMarket: null,
+                deposits: [],
+                borrows: []
+            };
+        }
+        const parsedObligation = this.parseObligation(obligation, obligationAccount.data);
         this.obligations.set(obligation, parsedObligation);
         return parsedObligation;
     }
-    _parseReserveAccount(data) {
+    parseReserveAccount(reserve, data) {
         const market = new web3_js.PublicKey(data.subarray(32, 64));
         const farmCollateral = new web3_js.PublicKey(data.subarray(64, 96));
         const farmDebt = new web3_js.PublicKey(data.subarray(96, 128));
         const liquidityMint = new web3_js.PublicKey(data.subarray(128, 160));
         return {
+            address: reserve,
             farmCollateral: farmCollateral.equals(web3_js.PublicKey.default) ? null : farmCollateral,
             farmDebt: farmDebt.equals(web3_js.PublicKey.default) ? null : farmDebt,
             liquidityMint,
@@ -18314,10 +19083,7 @@ class KaminoLendingClient {
             throw new Error("Not all reserves can be found");
         }
         return reserveAccounts.filter((a)=>!!a).map((account, i)=>{
-            const parsedReserve = {
-                address: reserves[i],
-                ...this._parseReserveAccount(account.data)
-            };
+            const parsedReserve = this.parseReserveAccount(reserves[i], account.data);
             this.reserves.set(reserves[i], parsedReserve);
             return parsedReserve;
         });
@@ -18345,14 +19111,55 @@ class KaminoLendingClient {
         if (accounts.length === 0) {
             throw new Error("Reserve not found");
         }
-        const account = accounts[0];
-        const parsedReserve = {
-            address: account.pubkey,
-            ...this._parseReserveAccount(account.account.data)
-        };
-        this.reserves.set(account.pubkey, parsedReserve);
+        const parsedReserve = this.parseReserveAccount(accounts[0].pubkey, accounts[0].account.data);
+        this.reserves.set(accounts[0].pubkey, parsedReserve);
         return parsedReserve;
     }
+    /**
+   * Finds and parses Kamino obligations for a given owner and market (optional)
+   */ async findAndParseObligations(owner, market) {
+        const accounts = await this.base.provider.connection.getProgramAccounts(KAMINO_LENDING_PROGRAM, {
+            filters: [
+                {
+                    dataSize: KAMINO_OBTRIGATION_SIZE
+                },
+                {
+                    memcmp: {
+                        offset: 64,
+                        bytes: owner.toBase58()
+                    }
+                },
+                ...market ? [
+                    {
+                        memcmp: {
+                            offset: 32,
+                            bytes: market.toBase58()
+                        }
+                    }
+                ] : []
+            ]
+        });
+        // Parse obligations and cache them
+        return accounts.map((a)=>{
+            const parsedObligation = this.parseObligation(a.pubkey, a.account.data);
+            this.obligations.set(a.pubkey, parsedObligation);
+            return parsedObligation;
+        });
+    }
+    async initUserMetadataTx(txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vault = this.base.vaultPda;
+        const userMetadata = this.getUserMetadataPda(vault);
+        const lookupTable = new web3_js.PublicKey(0); // FIXME: create lookup table
+        const tx = await this.base.program.methods.kaminoLendingInitUserMetadata(lookupTable).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            userMetadata,
+            referrerUserMetadata: null
+        }).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return vTx;
+    }
     async depositTx(market, asset, amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const vault = this.base.vaultPda;
@@ -19331,14 +20138,17 @@ class PriceClient {
    * !! If the vault has not been priced or pricing data is outdated, the number is NOT meaningful.
    */ async getAum() {
         console.warn("getAum() should only be used for testing. It doesn't reflect the actual AUM of the vault in production.");
-        // @ts-ignore
         const stateModel = await this.base.fetchStateModel();
         return (stateModel?.pricedAssets || []).reduce((sum, p)=>new anchor.BN(p.amount).add(sum), new anchor.BN(0));
     }
-    async priceKaminoIx(priceDenom) {
-        const glamVault = this.base.vaultPda;
-        const obligations = await fetchKaminoObligations(this.base.provider.connection, glamVault);
-        const parsedObligations = await Promise.all(obligations.map((o)=>this.klend.fetchAndParseObligation(o)));
+    /**
+   * Returns an instruction that prices Kamino obligations.
+   * If there are no Kamino obligations, returns null.
+   */ async priceKaminoObligationsIx(priceDenom) {
+        const parsedObligations = await this.klend.findAndParseObligations(this.base.vaultPda);
+        if (parsedObligations.length === 0) {
+            return null;
+        }
         const pubkeySet = new Set([]);
         parsedObligations.filter((o)=>o.lendingMarket !== null).map((o)=>{
             pubkeySet.add(o.address.toBase58());
@@ -19351,7 +20161,6 @@ class PriceClient {
                 isSigner: false,
                 isWritable: true
             }));
-        // @ts-ignore
         const priceIx = await this.base.program.methods.priceKaminoObligations(priceDenom).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE,
@@ -19362,81 +20171,152 @@ class PriceClient {
         }).remainingAccounts(remainingAccounts).instruction();
         return priceIx;
     }
-    async priceVaultIxs(priceDenom) {
-        const glamVault = this.base.vaultPda;
-        const priceVaultIx = await this.base.program.methods.priceVault(priceDenom).accounts({
+    /**
+   * Returns an instruction that prices the all Drift users (aka sub-accounts) controlled by the GLAM vault.
+   * These Drift users must share the same user_stats that's also controlled by the GLAM vault.
+   */ async priceDriftUsersIx(priceDenom) {
+        // FIXME: check more users than #0
+        const { user, userStats } = this.drift.getDriftUserPdas();
+        try {
+            const remainingAccounts = await this.drift.composeRemainingAccounts(0);
+            const priceDriftUsersIx = await this.base.program.methods.priceDriftUsers(priceDenom).accounts({
+                glamState: this.base.statePda,
+                solOracle: SOL_ORACLE
+            }).remainingAccounts([
+                {
+                    pubkey: userStats,
+                    isSigner: false,
+                    isWritable: false
+                },
+                {
+                    pubkey: user,
+                    isSigner: false,
+                    isWritable: false
+                },
+                ...remainingAccounts
+            ]).instruction();
+            return priceDriftUsersIx;
+        } catch (error) {
+            return null;
+        }
+    }
+    /**
+   * Returns an instruction that prices a drift vault depositor.
+   * If there are no vault depositor accounts, returns null.
+   */ async priceDriftVaultDepositorsIx(priceDenom) {
+        const parsedVaultDepositors = await this.driftVaults.findAndParseVaultDepositors();
+        if (parsedVaultDepositors.length === 0) {
+            return null;
+        }
+        // For each vault deposit, we need the following pubkeys in remaining accounts:
+        // - depositor
+        // - drift vault
+        // - drift user of the vault
+        // - oracles
+        // - spot & perp markets
+        // There might be overlaps between markets and oracles so we use a set to avoid duplicates
+        const remainingAccountsKeys = new Set();
+        for (const depositor of parsedVaultDepositors){
+            remainingAccountsKeys.add(depositor.address.toBase58());
+            remainingAccountsKeys.add(depositor.driftVault.toBase58());
+            const { user: driftUser } = await this.driftVaults.parseDriftVault(depositor.driftVault);
+            remainingAccountsKeys.add(driftUser.toBase58());
+            const markets_and_oracles = (await this.driftVaults.composeRemainingAccounts(driftUser)).map((a)=>a.pubkey.toBase58());
+            for (const k of markets_and_oracles){
+                remainingAccountsKeys.add(k);
+            }
+        }
+        const remainingAccounts = Array.from(remainingAccountsKeys).map((k)=>({
+                pubkey: new web3_js.PublicKey(k),
+                isSigner: false,
+                isWritable: false
+            }));
+        const priceIx = await this.base.program.methods.priceDriftVaultDepositors(priceDenom).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE
-        }).remainingAccounts(await this.remainingAccountsForPricingVaultAssets(priceDenom == PriceDenom.ASSET)).instruction();
-        // If priceDenom is ASSET, only priceVaultIx is returned
-        // We currently don't support pricing other assets in custom base asset
-        // due to the lack of oracles
-        if (priceDenom == PriceDenom.ASSET) {
-            return [
-                priceVaultIx
-            ];
-        }
-        const tickets = await fetchMarinadeTicketAccounts(this.base.provider.connection, glamVault);
-        // @ts-ignore
-        const priceTicketsIx = await this.base.program.methods.priceTickets(priceDenom).accounts({
+        }).remainingAccounts(remainingAccounts).instruction();
+        return priceIx;
+    }
+    /**
+   * Returns an instruction that prices vault balance and tokens the vault holds
+   */ async priceVaultIx(priceDenom) {
+        const remainingAccounts = await this.remainingAccountsForPricingVaultAssets(priceDenom == PriceDenom.ASSET);
+        const priceVaultIx = await this.base.program.methods.priceVault(priceDenom).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE
-        }).remainingAccounts(tickets.map((t)=>({
-                pubkey: t.pubkey,
-                isSigner: false,
-                isWritable: false
-            }))).instruction();
-        const stakes = await fetchStakeAccounts(this.base.provider.connection, glamVault);
+        }).remainingAccounts(remainingAccounts).instruction();
+        return priceVaultIx;
+    }
+    /**
+   * Returns an instruction that prices stake accounts.
+   * If there are no stake accounts, returns null.
+   */ async priceStakesIx(priceDenom) {
+        const stakes = await findStakeAccounts(this.base.provider.connection, this.base.vaultPda);
+        if (stakes.length === 0) {
+            return null;
+        }
         const priceStakesIx = await this.base.program.methods.priceStakes(priceDenom).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE
-        }).remainingAccounts(stakes.map((s)=>({
-                pubkey: s,
+        }).remainingAccounts(stakes.map((pubkey)=>({
+                pubkey,
                 isSigner: false,
                 isWritable: false
             }))).instruction();
+        return priceStakesIx;
+    }
+    /**
+   * Returns an instruction that prices Meteora positions.
+   * If there are no Meteora positions, returns null.
+   */ async priceMeteoraPositionsIx(priceDenom) {
+        const remainingAccounts = await this.remainingAccountsForPricingMeteora();
+        if (remainingAccounts.length === 0) {
+            return null;
+        }
         const priceMeteoraIx = await this.base.program.methods.priceMeteoraPositions(priceDenom).accounts({
             glamState: this.base.statePda,
             solOracle: SOL_ORACLE
-        }).remainingAccounts(await this.remainingAccountsForPricingMeteora()).instruction();
-        const priceKaminoIx = await this.priceKaminoIx(priceDenom);
-        try {
-            const { user, userStats } = this.drift.getDriftUserPdas();
-            const remainingAccounts = await this.drift.composeRemainingAccounts(0);
-            const priceDriftIx = await this.base.program.methods.priceDrift(priceDenom).accounts({
-                glamState: this.base.statePda,
-                glamVault,
-                solOracle: SOL_ORACLE,
-                user,
-                userStats,
-                state: this.drift.driftStatePda
-            }).remainingAccounts(remainingAccounts).instruction();
+        }).remainingAccounts(remainingAccounts).instruction();
+        return priceMeteoraIx;
+    }
+    async priceVaultIxs(priceDenom) {
+        const priceVaultIx = await this.priceVaultIx(priceDenom);
+        // If priceDenom is ASSET, only priceVaultIx is returned
+        // We currently don't support pricing other assets in custom base asset
+        // due to the lack of oracles
+        if (priceDenom == PriceDenom.ASSET) {
             return [
-                priceTicketsIx,
-                priceStakesIx,
-                priceVaultIx,
-                priceMeteoraIx,
-                priceKaminoIx,
-                priceDriftIx
+                priceVaultIx
             ];
-        } catch (error) {
-            // Drift user not found, skip priceDriftIx
+        }
+        // If there are no external assets, we don't need to price DeFi positions
+        const stateModel = await this.base.fetchStateModel();
+        if ((stateModel.externalVaultAccounts || []).length === 0) {
             return [
-                priceTicketsIx,
-                priceStakesIx,
-                priceVaultIx,
-                priceMeteoraIx,
-                priceKaminoIx
+                priceVaultIx
             ];
         }
-    }
-    constructor(base, klend, drift){
+        const priceStakesIx = await this.priceStakesIx(priceDenom);
+        const priceMeteoraIx = await this.priceMeteoraPositionsIx(priceDenom);
+        const priceKaminoIx = await this.priceKaminoObligationsIx(priceDenom);
+        const priceDriftUsersIx = await this.priceDriftUsersIx(priceDenom);
+        const priceDriftVaultDepositorsIx = await this.priceDriftVaultDepositorsIx(priceDenom);
+        return [
+            priceVaultIx,
+            priceStakesIx,
+            priceMeteoraIx,
+            priceKaminoIx,
+            priceDriftUsersIx,
+            priceDriftVaultDepositorsIx
+        ].filter((ix)=>ix !== null);
+    }
+    constructor(base, klend, drift, driftVaults){
         this.base = base;
         this.klend = klend;
         this.drift = drift;
+        this.driftVaults = driftVaults;
         this.remainingAccountsForPricingMeteora = async ()=>{
-            const glamVault = this.base.vaultPda;
-            const positions = await fetchMeteoraPositions(this.base.provider.connection, glamVault);
+            const positions = await fetchMeteoraPositions(this.base.provider.connection, this.base.vaultPda);
             let chunks = await Promise.all(positions.map(async (pubkey)=>{
                 const { lbPair, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, pubkey);
                 return [
@@ -19444,8 +20324,8 @@ class PriceClient {
                     lbPair,
                     binArrayLower,
                     binArrayUpper,
-                    new web3_js.PublicKey("3m6i4RFWEDw2Ft4tFHPJtYgmpPe21k56M3FHeWYrgGBz"),
-                    new web3_js.PublicKey("9VCioxmni2gDLv11qufWzT3RDERhQE4iY5Gf7NTfYyAV")
+                    SOL_ORACLE,
+                    USDC_ORACLE
                 ].map((k)=>({
                         pubkey: k,
                         isSigner: false,
@@ -19505,6 +20385,12 @@ class PriceClient {
         }
         return this._drift;
     }
+    get driftVaults() {
+        if (!this._driftVaults) {
+            this._driftVaults = new DriftVaultsClient(this, this.drift);
+        }
+        return this._driftVaults;
+    }
     get investor() {
         if (!this._investor) {
             this._investor = new InvestorClient(this);
@@ -19543,7 +20429,7 @@ class PriceClient {
     }
     get price() {
         if (!this._price) {
-            this._price = new PriceClient(this, this.kaminoLending, this.drift);
+            this._price = new PriceClient(this, this.kaminoLending, this.drift, this.driftVaults);
         }
         return this._price;
     }
@@ -19663,11 +20549,14 @@ exports.ContractTier = ContractTier;
 exports.ContractType = ContractType;
 exports.CreatedModel = CreatedModel;
 exports.DRIFT_PROGRAM_ID = DRIFT_PROGRAM_ID;
+exports.DRIFT_VAULTS_PROGRAM_ID = DRIFT_VAULTS_PROGRAM_ID;
+exports.DRIFT_VAULT_DEPOSITOR_SIZE = DRIFT_VAULT_DEPOSITOR_SIZE;
 exports.DefaultOrderParams = DefaultOrderParams;
 exports.DelegateAcl = DelegateAcl;
 exports.DepositDirection = DepositDirection;
 exports.DepositExplanation = DepositExplanation;
 exports.DriftClient = DriftClient;
+exports.DriftVaultsClient = DriftVaultsClient;
 exports.ExchangeStatus = ExchangeStatus;
 exports.FuelOverflowStatus = FuelOverflowStatus;
 exports.FundOpenfundsModel = FundOpenfundsModel;
@@ -19697,7 +20586,6 @@ exports.LPAction = LPAction;
 exports.LiquidationType = LiquidationType;
 exports.MARINADE_NATIVE_STAKE_AUTHORITY = MARINADE_NATIVE_STAKE_AUTHORITY;
 exports.MARINADE_PROGRAM_ID = MARINADE_PROGRAM_ID;
-exports.MARINADE_TICKET_SIZE = MARINADE_TICKET_SIZE;
 exports.MEMO_PROGRAM = MEMO_PROGRAM;
 exports.MERKLE_DISTRIBUTOR_PROGRAM = MERKLE_DISTRIBUTOR_PROGRAM;
 exports.METEORA_DLMM_PROGRAM = METEORA_DLMM_PROGRAM;
@@ -19751,15 +20639,14 @@ exports.TRANSFER_HOOK_PROGRAM = TRANSFER_HOOK_PROGRAM;
 exports.TimeUnit = TimeUnit;
 exports.TradeSide = TradeSide;
 exports.USDC = USDC;
+exports.USDC_ORACLE = USDC_ORACLE;
 exports.UserStatus = UserStatus;
 exports.WSOL = WSOL;
 exports.ZERO = ZERO;
 exports.decodeUser = decodeUser;
-exports.fetchKaminoObligations = fetchKaminoObligations;
 exports.fetchLookupTables = fetchLookupTables;
-exports.fetchMarinadeTicketAccounts = fetchMarinadeTicketAccounts;
 exports.fetchMeteoraPositions = fetchMeteoraPositions;
-exports.fetchStakeAccounts = fetchStakeAccounts;
+exports.findStakeAccounts = findStakeAccounts;
 exports.getAccountPolicyPda = getAccountPolicyPda;
 exports.getEscrowPda = getEscrowPda;
 exports.getExtraMetasPda = getExtraMetasPda;
@@ -19782,4 +20669,5 @@ exports.isBrowser = isBrowser;
 exports.isOneOfVariant = isOneOfVariant;
 exports.isVariant = isVariant;
 exports.parseMeteoraPosition = parseMeteoraPosition;
+exports.parseProgramLogs = parseProgramLogs;
 exports.setsAreEqual = setsAreEqual;