@glamsystems/glam-sdk 0.1.25 → 0.1.27

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.29",
     spec: "0.1.0",
     description: "Glam Protocol"
 };
@@ -1605,16 +1605,16 @@ var instructions = [
         ]
     },
     {
-        name: "drift_withdraw",
+        name: "drift_vaults_cancel_request_withdraw",
         discriminator: [
-            86,
-            59,
-            186,
-            123,
-            183,
-            181,
-            234,
-            137
+            241,
+            196,
+            156,
+            180,
+            21,
+            155,
+            228,
+            125
         ],
         accounts: [
             {
@@ -1622,7 +1622,69 @@ var instructions = [
             },
             {
                 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: [
                         {
@@ -1649,168 +1711,525 @@ var instructions = [
             },
             {
                 name: "cpi_program",
-                address: "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
             },
             {
-                name: "state"
+                name: "vault",
+                writable: true
             },
             {
-                name: "user",
+                name: "vault_depositor",
                 writable: true
             },
             {
-                name: "user_stats",
+                name: "vault_token_account",
                 writable: true
             },
             {
-                name: "spot_market_vault",
+                name: "drift_user_stats",
                 writable: true
             },
             {
-                name: "drift_signer"
+                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: "market_index",
-                type: "u16"
-            },
             {
                 name: "amount",
                 type: "u64"
-            },
-            {
-                name: "reduce_only",
-                type: "bool"
             }
         ]
     },
     {
-        name: "emergency_update_mint",
+        name: "drift_vaults_initialize_vault_depositor",
         discriminator: [
-            141,
-            210,
-            26,
-            160,
-            120,
-            140,
-            28,
-            239
+            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: "glam_mint",
-                writable: true
+                name: "cpi_program",
+                address: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
             },
             {
-                name: "token_2022_program",
-                address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
-            }
-        ],
-        args: [
+                name: "vault"
+            },
             {
-                name: "mint_id",
-                type: "u8"
+                name: "vault_depositor",
+                writable: true
             },
             {
-                name: "mint_model",
-                type: {
-                    defined: {
-                        name: "MintModel"
-                    }
-                }
+                name: "rent",
+                address: "SysvarRent111111111111111111111111111111111"
+            },
+            {
+                name: "system_program",
+                address: "11111111111111111111111111111111"
             }
-        ]
+        ],
+        args: []
     },
     {
-        name: "emergency_update_state",
+        name: "drift_vaults_request_withdraw",
         discriminator: [
-            156,
-            211,
-            55,
-            70,
-            92,
-            37,
-            190,
-            66
+            19,
+            53,
+            222,
+            51,
+            44,
+            215,
+            35,
+            82
         ],
         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: "vAuLTsyrvSfZRuRB3XgvkPwNGgYSs9YRYymVebLKoxR"
+            },
+            {
+                name: "vault",
+                writable: true
+            },
+            {
+                name: "vault_depositor",
+                writable: true
+            },
+            {
+                name: "drift_user_stats"
+            },
+            {
+                name: "drift_user"
             }
         ],
         args: [
             {
-                name: "state",
+                name: "withdraw_amount",
+                type: "u64"
+            },
+            {
+                name: "withdraw_unit",
                 type: {
                     defined: {
-                        name: "StateModel"
+                        name: "WithdrawUnit"
                     }
                 }
             }
         ]
     },
     {
-        name: "force_transfer_tokens",
+        name: "drift_vaults_withdraw",
         discriminator: [
-            185,
-            34,
-            78,
-            211,
-            192,
-            13,
-            160,
-            37
+            58,
+            127,
+            150,
+            177,
+            66,
+            45,
+            5,
+            30
         ],
         accounts: [
             {
-                name: "glam_state",
-                writable: true
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            },
-            {
-                name: "glam_mint",
-                writable: true
+                name: "glam_state"
             },
             {
-                name: "from_ata",
-                writable: true,
+                name: "glam_vault",
                 pda: {
                     seeds: [
                         {
-                            kind: "account",
-                            path: "from"
-                        },
-                        {
-                            kind: "account",
-                            path: "token_2022_program"
-                        },
+                            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: "drift_signer"
+            },
+            {
+                name: "user_token_account",
+                writable: true
+            },
+            {
+                name: "drift_program"
+            },
+            {
+                name: "token_program"
+            }
+        ],
+        args: []
+    },
+    {
+        name: "drift_withdraw",
+        discriminator: [
+            86,
+            59,
+            186,
+            123,
+            183,
+            181,
+            234,
+            137
+        ],
+        accounts: [
+            {
+                name: "glam_state"
+            },
+            {
+                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: "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+            },
+            {
+                name: "state"
+            },
+            {
+                name: "user",
+                writable: true
+            },
+            {
+                name: "user_stats",
+                writable: true
+            },
+            {
+                name: "spot_market_vault",
+                writable: true
+            },
+            {
+                name: "drift_signer"
+            },
+            {
+                name: "user_token_account",
+                writable: true
+            },
+            {
+                name: "token_program"
+            }
+        ],
+        args: [
+            {
+                name: "market_index",
+                type: "u16"
+            },
+            {
+                name: "amount",
+                type: "u64"
+            },
+            {
+                name: "reduce_only",
+                type: "bool"
+            }
+        ]
+    },
+    {
+        name: "emergency_update_mint",
+        discriminator: [
+            141,
+            210,
+            26,
+            160,
+            120,
+            140,
+            28,
+            239
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "glam_mint",
+                writable: true
+            },
+            {
+                name: "token_2022_program",
+                address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+            }
+        ],
+        args: [
+            {
+                name: "mint_id",
+                type: "u8"
+            },
+            {
+                name: "mint_model",
+                type: {
+                    defined: {
+                        name: "MintModel"
+                    }
+                }
+            }
+        ]
+    },
+    {
+        name: "emergency_update_state",
+        discriminator: [
+            156,
+            211,
+            55,
+            70,
+            92,
+            37,
+            190,
+            66
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            }
+        ],
+        args: [
+            {
+                name: "state",
+                type: {
+                    defined: {
+                        name: "StateModel"
+                    }
+                }
+            }
+        ]
+    },
+    {
+        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: [
+            185,
+            34,
+            78,
+            211,
+            192,
+            13,
+            160,
+            37
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "glam_mint",
+                writable: true
+            },
+            {
+                name: "from_ata",
+                writable: true,
+                pda: {
+                    seeds: [
+                        {
+                            kind: "account",
+                            path: "from"
+                        },
+                        {
+                            kind: "account",
+                            path: "token_2022_program"
+                        },
                         {
                             kind: "account",
                             path: "glam_mint"
@@ -3750,7 +4169,123 @@ var instructions = [
         ],
         accounts: [
             {
-                name: "glam_state"
+                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: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+            },
+            {
+                name: "obligation",
+                writable: true
+            },
+            {
+                name: "lending_market"
+            },
+            {
+                name: "lending_market_authority"
+            },
+            {
+                name: "withdraw_reserve",
+                writable: true
+            },
+            {
+                name: "reserve_liquidity_mint"
+            },
+            {
+                name: "reserve_source_collateral",
+                writable: true
+            },
+            {
+                name: "reserve_collateral_mint",
+                writable: true
+            },
+            {
+                name: "reserve_liquidity_supply",
+                writable: true
+            },
+            {
+                name: "user_destination_liquidity",
+                writable: true
+            },
+            {
+                name: "placeholder_user_destination_collateral",
+                optional: true
+            },
+            {
+                name: "collateral_token_program"
+            },
+            {
+                name: "liquidity_token_program"
+            },
+            {
+                name: "instruction_sysvar_account"
+            },
+            {
+                name: "obligation_farm_user_state",
+                writable: true,
+                optional: true
+            },
+            {
+                name: "reserve_farm_state",
+                writable: true,
+                optional: true
+            },
+            {
+                name: "farms_program"
+            }
+        ],
+        args: [
+            {
+                name: "collateral_amount",
+                type: "u64"
+            }
+        ]
+    },
+    {
+        name: "kamino_vaults_deposit",
+        discriminator: [
+            209,
+            133,
+            37,
+            193,
+            192,
+            217,
+            55,
+            40
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
             },
             {
                 name: "glam_vault",
@@ -3781,86 +4316,68 @@ var instructions = [
             },
             {
                 name: "cpi_program",
-                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+                address: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
             },
             {
-                name: "obligation",
+                name: "vault_state",
                 writable: true
             },
             {
-                name: "lending_market"
-            },
-            {
-                name: "lending_market_authority"
-            },
-            {
-                name: "withdraw_reserve",
+                name: "token_vault",
                 writable: true
             },
             {
-                name: "reserve_liquidity_mint"
+                name: "token_mint"
             },
             {
-                name: "reserve_source_collateral",
-                writable: true
+                name: "base_vault_authority"
             },
             {
-                name: "reserve_collateral_mint",
+                name: "shares_mint",
                 writable: true
             },
             {
-                name: "reserve_liquidity_supply",
+                name: "user_token_ata",
                 writable: true
             },
             {
-                name: "user_destination_liquidity",
+                name: "user_shares_ata",
                 writable: true
             },
             {
-                name: "placeholder_user_destination_collateral",
-                optional: true
-            },
-            {
-                name: "collateral_token_program"
-            },
-            {
-                name: "liquidity_token_program"
+                name: "klend_program"
             },
             {
-                name: "instruction_sysvar_account"
+                name: "token_program"
             },
             {
-                name: "obligation_farm_user_state",
-                writable: true,
-                optional: true
+                name: "shares_token_program"
             },
             {
-                name: "reserve_farm_state",
-                writable: true,
-                optional: true
+                name: "event_authority"
             },
             {
-                name: "farms_program"
+                name: "program"
             }
         ],
         args: [
             {
-                name: "collateral_amount",
+                name: "amount",
                 type: "u64"
             }
         ]
     },
     {
-        name: "marinade_claim",
+        name: "kamino_vaults_withdraw",
         discriminator: [
-            54,
-            44,
-            48,
-            204,
-            218,
-            141,
-            36,
-            5
+            82,
+            106,
+            49,
+            86,
+            156,
+            15,
+            87,
+            8
         ],
         accounts: [
             {
@@ -3896,29 +4413,95 @@ var instructions = [
             },
             {
                 name: "cpi_program",
-                address: "MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD"
+                address: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
             },
             {
-                name: "state",
+                name: "withdraw_from_available_vault_state",
                 writable: true
             },
             {
-                name: "reserve_pda",
+                name: "withdraw_from_available_token_vault",
                 writable: true
             },
             {
-                name: "ticket_account",
+                name: "withdraw_from_available_base_vault_authority"
+            },
+            {
+                name: "withdraw_from_available_user_token_ata",
                 writable: true
             },
             {
-                name: "clock"
+                name: "withdraw_from_available_token_mint",
+                writable: true
             },
             {
-                name: "system_program",
-                address: "11111111111111111111111111111111"
+                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: "withdraw_from_reserve_lending_market_authority"
+            },
+            {
+                name: "withdraw_from_reserve_reserve_liquidity_supply",
+                writable: true
+            },
+            {
+                name: "withdraw_from_reserve_reserve_collateral_mint",
+                writable: true
+            },
+            {
+                name: "withdraw_from_reserve_reserve_collateral_token_program"
+            },
+            {
+                name: "withdraw_from_reserve_instruction_sysvar_account"
+            },
+            {
+                name: "event_authority"
+            },
+            {
+                name: "program"
             }
         ],
-        args: []
+        args: [
+            {
+                name: "amount",
+                type: "u64"
+            }
+        ]
     },
     {
         name: "marinade_deposit",
@@ -4117,88 +4700,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: [
@@ -5757,45 +6258,165 @@ var instructions = [
                 writable: true
             },
             {
-                name: "policy_account",
+                name: "policy_account",
+                writable: true,
+                optional: true
+            },
+            {
+                name: "system_program",
+                address: "11111111111111111111111111111111"
+            },
+            {
+                name: "token_2022_program",
+                address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+            },
+            {
+                name: "policies_program",
+                address: "po1iCYakK3gHCLbuju4wGzFowTMpAJxkqK1iwUqMonY"
+            }
+        ],
+        args: [
+            {
+                name: "mint_id",
+                type: "u8"
+            },
+            {
+                name: "amount",
+                type: "u64"
+            }
+        ]
+    },
+    {
+        name: "price_drift_users",
+        discriminator: [
+            12,
+            5,
+            143,
+            51,
+            101,
+            81,
+            200,
+            150
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_vault",
+                pda: {
+                    seeds: [
+                        {
+                            kind: "const",
+                            value: [
+                                118,
+                                97,
+                                117,
+                                108,
+                                116
+                            ]
+                        },
+                        {
+                            kind: "account",
+                            path: "glam_state"
+                        }
+                    ]
+                }
+            },
+            {
+                name: "signer",
                 writable: true,
-                optional: true
-            },
-            {
-                name: "system_program",
-                address: "11111111111111111111111111111111"
+                signer: true
             },
             {
-                name: "token_2022_program",
-                address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+                name: "sol_oracle"
             },
             {
-                name: "policies_program",
-                address: "po1iCYakK3gHCLbuju4wGzFowTMpAJxkqK1iwUqMonY"
+                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: [
             {
-                name: "mint_id",
-                type: "u8"
-            },
-            {
-                name: "amount",
-                type: "u64"
+                name: "denom",
+                type: {
+                    defined: {
+                        name: "PriceDenom"
+                    }
+                }
             }
         ]
     },
     {
-        name: "price_drift",
+        name: "price_drift_vault_depositors",
         discriminator: [
-            240,
-            91,
-            209,
-            89,
-            155,
-            0,
-            97,
-            133
+            234,
+            16,
+            238,
+            70,
+            189,
+            23,
+            98,
+            160
         ],
         accounts: [
             {
@@ -5803,7 +6424,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 +6453,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: [
@@ -5873,7 +6565,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -5975,16 +6667,16 @@ var instructions = [
         ]
     },
     {
-        name: "price_meteora_positions",
+        name: "price_kamino_vault_shares",
         discriminator: [
-            186,
-            22,
-            157,
-            249,
-            185,
-            176,
-            253,
-            133
+            112,
+            92,
+            238,
+            224,
+            145,
+            105,
+            38,
+            249
         ],
         accounts: [
             {
@@ -6013,10 +6705,14 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
+            {
+                name: "kamino_lending_program",
+                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+            },
             {
                 name: "sol_oracle"
             },
@@ -6081,6 +6777,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 +6807,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 +6845,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -6215,16 +6927,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 +6965,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -6373,7 +7085,7 @@ var instructions = [
                 }
             },
             {
-                name: "glam_signer",
+                name: "signer",
                 writable: true,
                 signer: true
             },
@@ -9512,11 +10224,6 @@ var errors = [
         name: "InvalidAuthority",
         msg: "Invalid authority"
     },
-    {
-        code: 48009,
-        name: "InvalidPriceDenom",
-        msg: "Invalid price denom"
-    },
     {
         code: 49000,
         name: "InvalidAccountType",
@@ -9717,6 +10424,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 +11775,12 @@ var types = [
                 },
                 {
                     name: "MeteoraDlmm"
+                },
+                {
+                    name: "DriftVaults"
+                },
+                {
+                    name: "KaminoVaults"
                 }
             ]
         }
@@ -12168,6 +12901,18 @@ var types = [
                 },
                 {
                     name: "EmergencyUpdate"
+                },
+                {
+                    name: "DriftVaultsDeposit"
+                },
+                {
+                    name: "DriftVaultsWithdraw"
+                },
+                {
+                    name: "KaminoVaultsDeposit"
+                },
+                {
+                    name: "KaminoVaultsWithdraw"
                 }
             ]
         }
@@ -13024,6 +13769,23 @@ var types = [
                 }
             ]
         }
+    },
+    {
+        name: "WithdrawUnit",
+        type: {
+            kind: "enum",
+            variants: [
+                {
+                    name: "Shares"
+                },
+                {
+                    name: "Token"
+                },
+                {
+                    name: "SharesPercent"
+                }
+            ]
+        }
     }
 ];
 var constants = [
@@ -13090,10 +13852,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 +13873,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");
@@ -13119,6 +13882,7 @@ const MERKLE_DISTRIBUTOR_PROGRAM = new web3_js.PublicKey("DiS3nNjFVMieMgmiQFm6wg
 const TRANSFER_HOOK_PROGRAM = new web3_js.PublicKey("po1iCYakK3gHCLbuju4wGzFowTMpAJxkqK1iwUqMonY");
 const METEORA_DLMM_PROGRAM = new web3_js.PublicKey("LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo");
 const KAMINO_LENDING_PROGRAM = new web3_js.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD");
+const KAMINO_VAULTS_PROGRAM = new web3_js.PublicKey("KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd");
 const KAMINO_FARM_PROGRAM = new web3_js.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
 const MEMO_PROGRAM = new web3_js.PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
 /**
@@ -13519,7 +14283,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 +14350,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 +14406,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 +14469,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 +14489,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 +14652,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){
@@ -14074,7 +14826,7 @@ class BaseClient {
     set statePda(statePda) {
         this._statePda = statePda;
     }
-    isMainnet() {
+    get isMainnet() {
         return this.cluster === ClusterNetwork.Mainnet;
     }
     isPhantom() {
@@ -14089,7 +14841,7 @@ class BaseClient {
    * @returns Metadata of the asset
    */ getAssetMeta(assetMint) {
         let assetMeta = ASSETS_MAINNET.get(assetMint);
-        if (!assetMeta && !this.isMainnet()) {
+        if (!assetMeta && !this.isMainnet) {
             assetMeta = ASSETS_TESTS.get(assetMint);
         }
         if (!assetMeta) {
@@ -14221,18 +14973,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");
@@ -14487,9 +15231,9 @@ class BaseClient {
         if (stateAccount.mints.length > 0) {
             const mintPubkey = glamStatePda.equals(this.statePda) ? this.mintPda : getMintPda(glamStatePda, 0, this.program.programId);
             const { mint } = await this.fetchMintAndTokenProgram(mintPubkey);
-            return StateModel.fromOnchainAccounts(statePda, stateAccount, openfundsMetadataAccount, mint, this.program.programId);
+            return StateModel.fromOnchainAccounts(glamStatePda, stateAccount, openfundsMetadataAccount, mint, this.program.programId);
         }
-        return StateModel.fromOnchainAccounts(statePda, stateAccount, openfundsMetadataAccount, undefined, this.program.programId);
+        return StateModel.fromOnchainAccounts(glamStatePda, stateAccount, openfundsMetadataAccount, undefined, this.program.programId);
     }
     /**
    * Fetch all glam state models if no filter options provided
@@ -14709,6 +15453,12 @@ DepositDirection.WITHDRAW = {
     withdraw: {}
 };
 class OracleSource {
+    static fromString(name) {
+        const k = name.slice(0, 1).toLowerCase() + name.slice(1);
+        return {
+            [k]: {}
+        };
+    }
     static get(n) {
         const name = Object.entries(OracleSourceNum).find(([, v])=>v === n)?.[0];
         const source = Object.entries(OracleSource).find(([key, _])=>key.toLocaleLowerCase() === name?.toLocaleLowerCase())?.[1];
@@ -15107,6 +15857,82 @@ 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")
+]);
+borsh.struct([
+    borsh.array(borsh.u8(), 8, "discriminator"),
+    borsh.publicKey("marketPda"),
+    borsh.publicKey("oracle"),
+    borsh.publicKey("mint"),
+    borsh.publicKey("vault"),
+    borsh.array(borsh.u8(), 32, "name"),
+    // Padding for bytes between name and cumulativeDepositInterest
+    borsh.array(borsh.u8(), 464 - 168, "padding1"),
+    borsh.u128("cumulativeDepositInterest"),
+    borsh.u128("cumulativeBorrowInterest"),
+    // Padding for bytes between cumulativeBorrowInterest and decimals
+    borsh.array(borsh.u8(), 680 - 496, "padding2"),
+    borsh.u32("decimals"),
+    borsh.u16("marketIndex"),
+    borsh.u8("padding3"),
+    borsh.u8("oracleSource")
+]);
+
 function readUnsignedBigInt64LE(buffer, offset) {
     return new anchor.BN(buffer.subarray(offset, offset + 8), 10, "le");
 }
@@ -15566,17 +16392,17 @@ class DriftClient {
             Buffer.from("drift_state")
         ], DRIFT_PROGRAM_ID)[0];
     }
-    async fetchAndParseSpotMarket(marketIndex) {
+    async fetchAndParseSpotMarket(marketIndex, skipCache = false) {
         const markets = await this.fetchAndParseSpotMarkets([
             marketIndex
-        ]);
+        ], skipCache);
         if (!markets || markets.length === 0) {
             throw new Error(`Spot market not found at index ${marketIndex}`);
         }
         return markets[0];
     }
-    async fetchAndParseSpotMarkets(marketIndexes) {
-        const indexesToFetch = marketIndexes.filter((marketIndex)=>!this.spotMarkets.has(marketIndex));
+    async fetchAndParseSpotMarkets(marketIndexes, skipCache = false) {
+        const indexesToFetch = marketIndexes.filter((marketIndex)=>skipCache || !this.spotMarkets.has(marketIndex));
         if (indexesToFetch.length > 0) {
             if (process.env.NODE_ENV === "development") {
                 console.log("Fetching spot markets:", indexesToFetch);
@@ -15590,20 +16416,26 @@ 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) {
+    async fetchAndParsePerpMarket(marketIndex, skipCache = false) {
         const markets = await this.fetchAndParsePerpMarkets([
             marketIndex
-        ]);
+        ], skipCache);
         if (!markets || markets.length === 0) {
             throw new Error(`Perp market not found at index ${marketIndex}`);
         }
         return markets[0];
     }
-    async fetchAndParsePerpMarkets(marketIndexes) {
-        const indexesToFetch = marketIndexes.filter((marketIndex)=>!this.perpMarkets.has(marketIndex));
+    async fetchAndParsePerpMarkets(marketIndexes, skipCache = false) {
+        const indexesToFetch = marketIndexes.filter((marketIndex)=>skipCache || !this.perpMarkets.has(marketIndex));
         if (indexesToFetch.length > 0) {
             if (process.env.NODE_ENV === "development") {
                 console.log("Fetching perp markets:", indexesToFetch);
@@ -15621,35 +16453,63 @@ class DriftClient {
                 console.log("Requested perp markets already cached:", marketIndexes);
             }
         }
-        return marketIndexes.map((marketIndex)=>this.perpMarkets.get(marketIndex)).filter((m)=>m);
-    }
-    async fetchMarketConfigs() {
-        // const response = await fetch(
-        //   "https://api.glam.systems/v0/drift/market_configs/",
-        // );
-        // if (!response.ok) {
-        //   throw new Error(`Failed to fetch market configs: ${response.status}`);
-        // }
-        // const data = await response.json();
-        // const { orderConstants, perp, spot } = data;
-        // // Transform perp market from API to `PerpMarket` type
-        // const perpMarkets = perp.map((m: any) => ({
-        //   marketIndex: m.marketIndex,
-        //   marketPda: m.marketPDA,
-        //   oracle: new PublicKey(m.oracle),
-        // }));
-        // // Transform spot market from API to `SpotMarket` type
-        // const spotMarkets = spot.map((m: any) => ({
-        //   marketIndex: m.marketIndex,
-        //   marketPda: m.marketPDA,
-        //   oracle: new PublicKey(m.oracle),
-        //   mint: new PublicKey(m.mint),
-        //   vault: new PublicKey(m.vaultPDA),
-        //   decimals: m.decimals,
-        // }));
+        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(skipCache = false) {
+        // Attempt to fetch market configs from glam API first
+        const glamApi = process.env.NEXT_PUBLIC_GLAM_API || process.env.GLAM_API;
+        if (glamApi) {
+            const response = await fetch(`${glamApi}/v0/drift/market_configs/`);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch market configs from ${glamApi}: ${response.status}`);
+            }
+            const data = await response.json();
+            const { orderConstants, perp, spot } = data;
+            // Transform perp market from API to `PerpMarket` type
+            const perpMarkets = perp.map((m)=>({
+                    name: m.symbol,
+                    marketIndex: m.marketIndex,
+                    marketPda: new web3_js.PublicKey(m.marketPDA),
+                    oracle: new web3_js.PublicKey(m.oracle),
+                    oracleSource: OracleSource.fromString(m.oracleSource)
+                }));
+            perpMarkets.forEach((m)=>{
+                this.perpMarkets.set(m.marketIndex, m);
+            });
+            // Transform spot market from API to `SpotMarket` type
+            const spotMarkets = spot.map((m)=>({
+                    name: m.symbol,
+                    marketIndex: m.marketIndex,
+                    marketPda: new web3_js.PublicKey(m.marketPDA),
+                    vault: new web3_js.PublicKey(m.vaultPDA),
+                    oracle: new web3_js.PublicKey(m.oracle),
+                    oracleSource: OracleSource.fromString(m.oracleSource),
+                    mint: new web3_js.PublicKey(m.mint),
+                    decimals: m.decimals,
+                    tokenProgram: new web3_js.PublicKey(m.tokenProgram),
+                    cumulativeDepositInterest: new anchor.BN(m.cumulativeDepositInterest),
+                    cumulativeBorrowInterest: new anchor.BN(m.cumulativeBorrowInterest)
+                }));
+            spotMarkets.forEach((m)=>{
+                this.spotMarkets.set(m.marketIndex, m);
+            });
+            const marketConfigs = {
+                orderConstants,
+                perpMarkets,
+                spotMarkets
+            };
+            this.marketConfigs = marketConfigs;
+            return marketConfigs;
+        }
+        // If glam API is not available, fetch market configs from RPC
         if (!this.marketConfigs) {
-            const perpMarkets = await this.fetchAndParsePerpMarkets(Array.from(Array(100).keys()));
-            const spotMarkets = await this.fetchAndParseSpotMarkets(Array.from(Array(100).keys()));
+            const perpMarkets = await this.fetchAndParsePerpMarkets(Array.from(Array(100).keys()), skipCache);
+            const spotMarkets = await this.fetchAndParseSpotMarkets(Array.from(Array(100).keys()), skipCache);
             this.marketConfigs = {
                 orderConstants: {
                     perpBaseScale: 9,
@@ -15661,24 +16521,10 @@ class DriftClient {
         }
         return this.marketConfigs;
     }
-    // public async fetchGlamDriftUser(
-    //   glamState: PublicKey | string,
-    //   subAccountId: number = 0,
-    // ): Promise<GlamDriftUser> {
-    //   const vault = this.base.getVaultPda(new PublicKey(glamState));
-    //   const response = await fetch(
-    //     `https://api.glam.systems/v0/drift/user?authority=${vault.toBase58()}&accountId=${subAccountId}`,
-    //   );
-    //   const data = await response.json();
-    //   if (!data) {
-    //     throw new Error("Failed to fetch drift user.");
-    //   }
-    //   return data as GlamDriftUser;
-    // }
     charsToName(chars) {
         return String.fromCharCode(...chars).replace(/\0/g, "").trim();
     }
-    async fetchDriftUser(subAccountId = 0) {
+    async fetchDriftUser(subAccountId = 0, skipCache = false) {
         const { user } = this.getDriftUserPdas(subAccountId);
         const accountInfo = await this.base.provider.connection.getAccountInfo(user);
         if (!accountInfo) {
@@ -15686,7 +16532,7 @@ class DriftClient {
         }
         const { delegate, name, spotPositions, marginMode, perpPositions, isMarginTradingEnabled, maxMarginRatio, orders } = decodeUser(accountInfo.data);
         // Prefetch market configs
-        const marketConfigs = await this.fetchMarketConfigs();
+        const marketConfigs = await this.fetchMarketConfigs(skipCache);
         const spotPositionsExt = await Promise.all(spotPositions.map(async (p)=>{
             const { amount, uiAmount } = await this.calcSpotBalance(p.marketIndex, p.scaledBalance, p.balanceType);
             const spotMarket = marketConfigs.spotMarkets.find((m)=>m.marketIndex === p.marketIndex);
@@ -15711,22 +16557,10 @@ class DriftClient {
             maxMarginRatio
         };
     }
-    // async getPositions(statePda: PublicKey | string, subAccountId: number = 0) {
-    //   const driftUser = await this.fetchDriftUser(
-    //     new PublicKey(statePda),
-    //     subAccountId,
-    //   );
-    //   if (!driftUser) {
-    //     return { spotPositions: [], perpPositions: [] };
-    //   }
-    //   const marketConfigs = await this.fetchMarketConfigs();
-    //   const { spotPositions, perpPositions } = driftUser;
-    //   return { spotPositions, perpPositions };
-    // }
     /**
    * @deprecated
-   */ async fetchPolicyConfig(glamState) {
-        const driftUserAccount = glamState && glamState.id && await this.fetchDriftUser();
+   */ async fetchPolicyConfig(stateModel) {
+        const driftUserAccount = await this.fetchDriftUser();
         let delegate = driftUserAccount?.delegate;
         if (delegate && delegate.equals(web3_js.PublicKey.default)) {
             delegate = undefined;
@@ -15734,11 +16568,11 @@ class DriftClient {
         return {
             driftAccessControl: delegate ? 0 : 1,
             driftDelegatedAccount: delegate || null,
-            driftMarketIndexesPerp: glamState?.driftMarketIndexesPerp || [],
-            driftOrderTypes: glamState?.driftOrderTypes || [],
+            driftMarketIndexesPerp: stateModel?.driftMarketIndexesPerp || [],
+            driftOrderTypes: stateModel?.driftOrderTypes || [],
             driftMaxLeverage: driftUserAccount?.maxMarginRatio ? DRIFT_MARGIN_PRECISION / driftUserAccount?.maxMarginRatio : null,
             driftEnableSpot: driftUserAccount?.isMarginTradingEnabled || false,
-            driftMarketIndexesSpot: glamState?.driftMarketIndexesSpot || []
+            driftMarketIndexesSpot: stateModel?.driftMarketIndexesSpot || []
         };
     }
     async composeRemainingAccounts(subAccountId, marketType, marketIndex) {
@@ -15833,7 +16667,8 @@ class DriftClient {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { user } = this.getDriftUserPdas(subAccountId);
         // https://github.com/drift-labs/protocol-v2/blob/babed162b08b1fe34e49a81c5aa3e4ec0a88ecdf/programs/drift/src/math/constants.rs#L183-L184
-        const marginRatio = DRIFT_MARGIN_PRECISION / maxLeverage;
+        // 0 means No Limit
+        const marginRatio = maxLeverage === 0 ? 0 : DRIFT_MARGIN_PRECISION / maxLeverage;
         return await this.base.program.methods.driftUpdateUserCustomMarginRatio(subAccountId, marginRatio).accounts({
             glamState: this.base.statePda,
             glamSigner,
@@ -16082,6 +16917,190 @@ class DriftClient {
         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();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async withdraw(driftVault, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        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,
+            vault: driftVault,
+            vaultDepositor,
+            vaultTokenAccount,
+            driftUserStats,
+            driftUser,
+            driftSpotMarketVault,
+            driftSigner: DRIFT_SIGNER,
+            userTokenAccount,
+            driftState: this.drift.driftStatePda,
+            driftProgram: DRIFT_PROGRAM_ID,
+            tokenProgram
+        }).remainingAccounts(remainingAccounts).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    constructor(base, drift){
+        this.base = base;
+        this.drift = drift;
+    }
+}
 
 const BASE = new web3_js.PublicKey("bJ1TRoFo2P6UHVwqdiipp6Qhp2HaaHpLowZ5LHet8Gm");
 class JupiterSwapClient {
@@ -16153,8 +17172,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 +17511,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 +17681,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
@@ -16703,79 +17692,39 @@ class MarinadeClient {
         // Fetch stake accounts by withdraw authority
         // Filter by state "active" does not work in localnet tests
         const stakeAccounts = await getStakeAccountsWithStates(this.base.provider.connection, stakeWithdrawAuthority);
-        const { stakeIndex, validatorIndex } = await this.getIndexes(stakeAccounts[0], stakeList, validatorList);
+        const idx = this.base.cluster === ClusterNetwork.Mainnet ? stakeAccounts.findIndex((s)=>s.state === "active") : 0;
+        const { stakeIndex, validatorIndex } = await this.getIndexes(stakeAccounts[idx], 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,
             state: marinadeState.marinadeStateAddress,
             validatorList: validatorList.account,
             stakeList: stakeList.account,
-            stakeAccount: stakeAccounts[0].address,
-            stakeWithdrawAuthority,
-            stakeDepositAuthority,
-            treasuryMsolAccount: marinadeState.treasuryMsolAccount,
-            msolMint: MSOL,
-            burnMsolFrom,
-            splitStakeAccount: newStake.publicKey,
-            clock: web3_js.SYSVAR_CLOCK_PUBKEY,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            stakeProgram: web3_js.StakeProgram.programId
-        }).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);
+            stakeAccount: stakeAccounts[idx].address,
+            stakeWithdrawAuthority,
+            stakeDepositAuthority,
+            treasuryMsolAccount: marinadeState.treasuryMsolAccount,
+            msolMint: MSOL,
+            burnMsolFrom,
+            splitStakeAccount: newStake.publicKey,
+            clock: web3_js.SYSVAR_CLOCK_PUBKEY,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            stakeProgram: web3_js.StakeProgram.programId
+        }).postInstructions(postInstructions).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return [
+            vTx,
+            newStake
+        ];
     }
     constructor(base){
         this.base = base;
@@ -16931,7 +17880,7 @@ class VaultClient {
         const tx = new web3_js.Transaction().add(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, vaultAta, this.base.vaultPda, asset, tokenProgram), splToken.createTransferCheckedInstruction(signerAta, asset, vaultAta, signer, new anchor.BN(amount).toNumber(), mint.decimals, [], tokenProgram));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async withdrawIxs(asset, amount, txOptions) {
+    async withdrawIxs(asset, amount, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { tokenProgram } = await this.base.fetchMintAndTokenProgram(asset);
         const signerAta = this.base.getAta(asset, glamSigner, tokenProgram);
@@ -16968,20 +17917,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 +17937,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 +18156,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 +18410,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({
@@ -17857,11 +18809,69 @@ class MintClient {
     }
 }
 
+const MAX_RESERVES = 25;
+const VaultAllocationLayout = borsh.struct([
+    borsh.publicKey("reserve"),
+    borsh.publicKey("ctokenVault"),
+    borsh.u64("targetAllocationWeight"),
+    borsh.u64("tokenAllocationCap"),
+    borsh.u64("ctokenVaultBump"),
+    borsh.array(borsh.u64(), 127, "configPadding"),
+    borsh.u64("ctokenAllocation"),
+    borsh.u64("lastInvestSlot"),
+    borsh.u128("tokenTargetAllocationSf"),
+    borsh.array(borsh.u64(), 128, "statePadding")
+]);
+const KVaultStateLayout = borsh.struct([
+    borsh.array(borsh.u8(), 8, "discriminator"),
+    // Admin
+    borsh.publicKey("vaultAdminAuthority"),
+    borsh.publicKey("baseVaultAuthority"),
+    borsh.u64("baseVaultAuthorityBump"),
+    borsh.publicKey("tokenMint"),
+    borsh.u64("tokenMintDecimals"),
+    borsh.publicKey("tokenVault"),
+    borsh.publicKey("tokenProgram"),
+    // shares
+    borsh.publicKey("sharesMint"),
+    borsh.u64("sharesMintDecimals"),
+    // accounting
+    borsh.u64("tokenAvailable"),
+    borsh.u64("sharesIssued"),
+    borsh.u64("availableCrankFunds"),
+    borsh.u64("padding0"),
+    borsh.u64("performanceFeeBps"),
+    borsh.u64("managementFeeBps"),
+    borsh.u64("lastFeeChargeTimestamp"),
+    borsh.u128("prevAumSf"),
+    borsh.u128("pendingFeesSf"),
+    borsh.array(VaultAllocationLayout, MAX_RESERVES, "vaultAllocationStrategy"),
+    borsh.array(borsh.u128(), 256, "padding1"),
+    // General config
+    borsh.u64("minDepositAmount"),
+    borsh.u64("minWithdrawAmount"),
+    borsh.u64("minInvestAmount"),
+    borsh.u64("minInvestDelaySlots"),
+    borsh.u64("crankFundFeePerReserve"),
+    borsh.publicKey("pendingAdmin"),
+    borsh.u128("cumulativeEarnedInterestSf"),
+    borsh.u128("cumulativeMgmtFeesSf"),
+    borsh.u128("cumulativePerfFeesSf"),
+    borsh.array(borsh.u8(), 40, "name"),
+    borsh.publicKey("vaultLookupTable"),
+    borsh.publicKey("vaultFarm"),
+    borsh.u64("creationTimestamp"),
+    borsh.u64("padding2"),
+    borsh.publicKey("allocationAdmin"),
+    borsh.array(borsh.u128(), 242, "padding3")
+]);
+
 const LOOKUP_TABLE = new web3_js.PublicKey("284iwGtA9X9aLy3KsyV8uT2pXLARhYbiSi5SiM2g47M2");
 const DEFAULT_OBLIGATION_ARGS = {
     tag: 0,
     id: 0
 };
+const EVENT_AUTHORITY$1 = new web3_js.PublicKey("24tHwQyJJ9akVXxnvkekGfAoeUJXXS7mE6kQNioNySsK");
 function refreshObligation(accounts, programId = KAMINO_LENDING_PROGRAM) {
     const keys = [
         {
@@ -18024,7 +19034,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 +19133,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 +19230,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 +19260,41 @@ class KaminoLendingClient {
                 reserve
             };
         }).filter((d)=>!d.reserve.equals(web3_js.PublicKey.default));
-        const parsedObligation = {
+        return {
             address: obligation,
             lendingMarket,
             deposits,
             borrows
         };
-        this.obligations.set(obligation, parsedObligation);
+    }
+    /**
+   * Fetches and parses an obligation account
+   */ async fetchAndParseObligation(obligation) {
+        const cached = this.obligations.get(obligation.toBase58());
+        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.toBase58(), 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,
+            market,
             farmCollateral: farmCollateral.equals(web3_js.PublicKey.default) ? null : farmCollateral,
             farmDebt: farmDebt.equals(web3_js.PublicKey.default) ? null : farmDebt,
             liquidityMint,
@@ -18306,19 +19302,28 @@ class KaminoLendingClient {
         };
     }
     async fetchAndParseReserves(reserves) {
-        if (this.pubkeyArraysEqual(reserves, Array.from(this.reserves.keys()))) {
-            return Array.from(this.reserves.values());
+        const requestReservesSet = new Set(reserves.map((r)=>r.toBase58()));
+        const cachedReservesSet = new Set(this.reserves.keys());
+        // If all requested reserves are cached, return data from cache
+        if ([
+            ...requestReservesSet
+        ].every((r)=>cachedReservesSet.has(r))) {
+            return Array.from(this.reserves.values()).filter((r)=>requestReservesSet.has(r.address.toBase58()));
         }
-        const reserveAccounts = await this.base.provider.connection.getMultipleAccountsInfo(reserves);
-        if (reserveAccounts.find((a)=>!a)) {
+        // Only fetch reserves that are not cached
+        const reservesToFetch = [
+            ...requestReservesSet
+        ].filter((r)=>!cachedReservesSet.has(r)).map((r)=>new web3_js.PublicKey(r));
+        if (process.env.NODE_ENV !== "production") {
+            console.log("Fetching reserves:", reservesToFetch.map((r)=>r.toBase58()));
+        }
+        const reserveAccounts = await this.base.provider.connection.getMultipleAccountsInfo(reservesToFetch);
+        if (reserveAccounts.some((a)=>!a)) {
             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)
-            };
-            this.reserves.set(reserves[i], parsedReserve);
+        return reserveAccounts.map((account, i)=>{
+            const parsedReserve = this.parseReserveAccount(reserves[i], account.data);
+            this.reserves.set(reserves[i].toBase58(), parsedReserve);
             return parsedReserve;
         });
     }
@@ -18345,14 +19350,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.toBase58(), 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.toBase58(), 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;
@@ -18866,6 +19912,160 @@ class KaminoFarmClient {
             ], KAMINO_FARM_PROGRAM)[0];
     }
 }
+class KaminoVaultsClient {
+    async deposit(vault, amount, txOptions = {}) {
+        const tx = await this.depositTx(vault, amount, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
+    async withdraw(vault, amount, txOptions = {}) {
+        const tx = await this.withdrawTx(vault, amount, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
+    async findAndParseKaminoVaults() {
+        const accounts = await this.base.provider.connection.getProgramAccounts(KAMINO_VAULTS_PROGRAM, {
+            filters: [
+                {
+                    dataSize: 62552
+                },
+                {
+                    memcmp: {
+                        offset: 0,
+                        bytes: "5MRSpWLS65g=",
+                        encoding: "base64"
+                    }
+                }
+            ]
+        });
+        if (accounts.length === 0) {
+            throw new Error("Kamino vaults not found");
+        }
+        return accounts.map((a)=>{
+            const vaultState = KVaultStateLayout.decode(a.account.data);
+            this.vaultStates.set(a.pubkey.toBase58(), vaultState);
+            this.shareMintToVaultPdaMap.set(vaultState.sharesMint.toBase58(), a.pubkey);
+            return vaultState;
+        });
+    }
+    async getVaultPdasByShareMints(mints) {
+        if (this.vaultStates.size === 0) {
+            await this.findAndParseKaminoVaults();
+        }
+        return mints.map((mint)=>this.shareMintToVaultPdaMap.get(mint.toBase58()));
+    }
+    async fetchAndParseVaultState(vault) {
+        const vaultAccount = await this.base.provider.connection.getAccountInfo(vault);
+        if (!vaultAccount) {
+            throw new Error(`Kamino vault account not found:, ${vault}`);
+        }
+        const vaultState = KVaultStateLayout.decode(vaultAccount.data);
+        this.vaultStates.set(vault.toBase58(), vaultState);
+        this.shareMintToVaultPdaMap.set(vaultState.sharesMint.toBase58(), vault);
+        return vaultState;
+    }
+    async composeRemainingAccounts(allocationStrategies) {
+        // For each allocation get reserve and market pubkeys
+        const reserves = allocationStrategies.map((strategy)=>strategy.reserve);
+        const parsedReserves = await this.kaminoLending.fetchAndParseReserves(reserves);
+        const reserveMetas = reserves.map((pubkey)=>({
+                pubkey,
+                isSigner: false,
+                isWritable: true
+            }));
+        const marketMetas = parsedReserves.map(({ market })=>({
+                pubkey: market,
+                isSigner: false,
+                isWritable: false
+            }));
+        return [
+            ...reserveMetas,
+            ...marketMetas
+        ];
+    }
+    async depositTx(vault, amount, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultState = await this.fetchAndParseVaultState(vault);
+        const amountBN = new anchor.BN(amount * 10 ** vaultState.tokenMintDecimals.toNumber());
+        const { tokenProgram: sharesTokenProgram } = await this.base.fetchMintAndTokenProgram(vaultState.sharesMint);
+        const userTokenAta = this.base.getVaultAta(vaultState.tokenMint, vaultState.tokenProgram);
+        const userSharesAta = this.base.getVaultAta(vaultState.sharesMint, sharesTokenProgram);
+        // Create user shares ata
+        const preInstructions = [
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userSharesAta, this.base.vaultPda, vaultState.sharesMint, sharesTokenProgram)
+        ];
+        // Remaining accounts, skip empty allocation strategies
+        const remainingAccounts = await this.composeRemainingAccounts(vaultState.vaultAllocationStrategy.filter(({ reserve })=>!reserve.equals(web3_js.PublicKey.default)));
+        const tx = await this.base.program.methods.kaminoVaultsDeposit(amountBN).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            vaultState: vault,
+            tokenVault: vaultState.tokenVault,
+            tokenMint: vaultState.tokenMint,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            sharesMint: vaultState.sharesMint,
+            userTokenAta,
+            userSharesAta,
+            klendProgram: KAMINO_LENDING_PROGRAM,
+            tokenProgram: vaultState.tokenProgram,
+            sharesTokenProgram,
+            eventAuthority: EVENT_AUTHORITY$1,
+            program: KAMINO_VAULTS_PROGRAM
+        }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return vTx;
+    }
+    async withdrawTx(vault, amount, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const vaultState = await this.fetchAndParseVaultState(vault);
+        const userTokenAta = this.base.getVaultAta(vaultState.tokenMint, vaultState.tokenProgram);
+        const { tokenProgram: sharesTokenProgram } = await this.base.fetchMintAndTokenProgram(vaultState.sharesMint);
+        const userSharesAta = this.base.getVaultAta(vaultState.sharesMint, sharesTokenProgram);
+        const amountBN = new anchor.BN(amount * 10 ** vaultState.sharesMintDecimals.toNumber());
+        const reserves = vaultState.vaultAllocationStrategy.filter(({ reserve })=>!reserve.equals(web3_js.PublicKey.default));
+        // Withdraw from the first reserve when kvault does not have enough liquidity
+        const idx = 0;
+        const withdrawReserve = (await this.kaminoLending.fetchAndParseReserves(reserves.map((r)=>r.reserve)))[idx];
+        const vaultCollateralTokenVault = vaultState.vaultAllocationStrategy[idx].ctokenVault;
+        const remainingAccounts = await this.composeRemainingAccounts(reserves);
+        const preInstructions = [
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userTokenAta, this.base.vaultPda, vaultState.tokenMint, vaultState.tokenProgram)
+        ];
+        const tx = await this.base.program.methods.kaminoVaultsWithdraw(amountBN).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            withdrawFromAvailableVaultState: vault,
+            withdrawFromAvailableTokenVault: vaultState.tokenVault,
+            withdrawFromAvailableBaseVaultAuthority: vaultState.baseVaultAuthority,
+            withdrawFromAvailableUserTokenAta: userTokenAta,
+            withdrawFromAvailableTokenMint: vaultState.tokenMint,
+            withdrawFromAvailableUserSharesAta: userSharesAta,
+            withdrawFromAvailableSharesMint: vaultState.sharesMint,
+            withdrawFromAvailableTokenProgram: vaultState.tokenProgram,
+            withdrawFromAvailableSharesTokenProgram: sharesTokenProgram,
+            withdrawFromAvailableKlendProgram: KAMINO_LENDING_PROGRAM,
+            withdrawFromAvailableEventAuthority: EVENT_AUTHORITY$1,
+            withdrawFromAvailableProgram: KAMINO_VAULTS_PROGRAM,
+            withdrawFromReserveVaultState: vault,
+            withdrawFromReserveReserve: withdrawReserve.address,
+            withdrawFromReserveCtokenVault: vaultCollateralTokenVault,
+            withdrawFromReserveLendingMarket: withdrawReserve.market,
+            withdrawFromReserveLendingMarketAuthority: this.kaminoLending.getMarketAuthority(withdrawReserve.market),
+            withdrawFromReserveReserveLiquiditySupply: withdrawReserve.liquiditySupplyVault,
+            withdrawFromReserveReserveCollateralMint: withdrawReserve.collateralMint,
+            withdrawFromReserveReserveCollateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
+            withdrawFromReserveInstructionSysvarAccount: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
+            eventAuthority: EVENT_AUTHORITY$1,
+            program: KAMINO_VAULTS_PROGRAM
+        }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return vTx;
+    }
+    constructor(base, kaminoLending){
+        this.base = base;
+        this.kaminoLending = kaminoLending;
+        this.vaultStates = new Map();
+        this.shareMintToVaultPdaMap = new Map();
+    }
+}
 
 // Pubkey::find_program_address(&[b"__event_authority"], &dlmm_interface::ID)
 const EVENT_AUTHORITY = new web3_js.PublicKey("D1ZN9Wj1fRSUQfCjhvnu1hqDMT7hzjzBBpi12nVniYD6");
@@ -19331,14 +20531,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 +20554,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 +20564,193 @@ 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({
+    async priceKaminoVaultSharesIx(priceDenom) {
+        const allKvaultStates = await this.kvaults.findAndParseKaminoVaults();
+        const allKvaultMints = allKvaultStates.map((kvault)=>kvault.sharesMint);
+        // All share token accounts GLAM vault could possibly hold
+        const possibleShareAtas = allKvaultMints.map((mint)=>this.base.getVaultAta(mint));
+        const possibleShareAtaAccountsInfo = await this.base.provider.connection.getMultipleAccountsInfo(possibleShareAtas);
+        const shareAtas = [];
+        const shareMints = [];
+        const kvaultStates = [];
+        possibleShareAtaAccountsInfo.forEach((info, i)=>{
+            if (info !== null) {
+                shareAtas.push(possibleShareAtas[i]);
+                shareMints.push(allKvaultMints[i]);
+                kvaultStates.push(allKvaultStates[i]);
+            }
+        });
+        const kvaultPdas = await this.kvaults.getVaultPdasByShareMints(shareMints);
+        const remainingAccounts = (await Promise.all(kvaultStates.map((kvault)=>{
+            return this.kvaults.composeRemainingAccounts(kvault.vaultAllocationStrategy.filter((alloc)=>!alloc.reserve.equals(web3_js.PublicKey.default)));
+        }))).flat();
+        [
+            ...kvaultPdas,
+            ...shareAtas
+        ].map((pubkey)=>{
+            remainingAccounts.unshift({
+                pubkey: pubkey,
+                isSigner: false,
+                isWritable: false
+            });
+        });
+        const priceIx = await this.base.program.methods.priceKaminoVaultShares(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
-            ];
+            solOracle: SOL_ORACLE,
+            pythOracle: null,
+            switchboardPriceOracle: null,
+            switchboardTwapOracle: null,
+            scopePrices: KAMINO_SCOPE_PRICES
+        }).remainingAccounts(remainingAccounts).instruction();
+        return priceIx;
+    }
+    /**
+   * 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;
         }
-        const tickets = await fetchMarinadeTicketAccounts(this.base.provider.connection, glamVault);
-        // @ts-ignore
-        const priceTicketsIx = await this.base.program.methods.priceTickets(priceDenom).accounts({
-            glamState: this.base.statePda,
-            solOracle: SOL_ORACLE
-        }).remainingAccounts(tickets.map((t)=>({
-                pubkey: t.pubkey,
+    }
+    /**
+   * 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.dvaults.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.dvaults.parseDriftVault(depositor.driftVault);
+            remainingAccountsKeys.add(driftUser.toBase58());
+            const markets_and_oracles = (await this.dvaults.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
-            }))).instruction();
-        const stakes = await fetchStakeAccounts(this.base.provider.connection, glamVault);
+            }));
+        const priceIx = await this.base.program.methods.priceDriftVaultDepositors(priceDenom).accounts({
+            glamState: this.base.statePda,
+            solOracle: SOL_ORACLE
+        }).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(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, kvaults, drift, dvaults){
         this.base = base;
         this.klend = klend;
+        this.kvaults = kvaults;
         this.drift = drift;
+        this.dvaults = dvaults;
         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 +20758,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 +20819,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 +20863,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.kaminoVaults, this.drift, this.driftVaults);
         }
         return this._price;
     }
@@ -19571,6 +20891,12 @@ class PriceClient {
         }
         return this._kaminoFarm;
     }
+    get kaminoVaults() {
+        if (!this._kaminoVaults) {
+            this._kaminoVaults = new KaminoVaultsClient(this, this.kaminoLending);
+        }
+        return this._kaminoVaults;
+    }
     get meteoraDlmm() {
         if (!this._meteoraDlmm) {
             this._meteoraDlmm = new MeteoraDlmmClient(this);
@@ -19663,11 +20989,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;
@@ -19693,11 +21022,11 @@ exports.KAMINO_FARM_PROGRAM = KAMINO_FARM_PROGRAM;
 exports.KAMINO_LENDING_PROGRAM = KAMINO_LENDING_PROGRAM;
 exports.KAMINO_OBTRIGATION_SIZE = KAMINO_OBTRIGATION_SIZE;
 exports.KAMINO_SCOPE_PRICES = KAMINO_SCOPE_PRICES;
+exports.KAMINO_VAULTS_PROGRAM = KAMINO_VAULTS_PROGRAM;
 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 +21080,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 +21110,5 @@ exports.isBrowser = isBrowser;
 exports.isOneOfVariant = isOneOfVariant;
 exports.isVariant = isVariant;
 exports.parseMeteoraPosition = parseMeteoraPosition;
+exports.parseProgramLogs = parseProgramLogs;
 exports.setsAreEqual = setsAreEqual;