@glamsystems/glam-sdk 0.1.22 → 0.1.23

package/index.cjs.js

@@ -33,7 +33,7 @@ var borsh__namespace = /*#__PURE__*/_interopNamespaceDefault(borsh);
 var address = "GLAMbTqav9N9witRjswJ8enwp9vv5G8bsSJ2kPJ4rcyc";
 var metadata = {
     name: "glam_protocol",
-    version: "0.4.16",
+    version: "0.4.20",
     spec: "0.1.0",
     description: "Glam Protocol"
 };
@@ -1691,6 +1691,86 @@ var instructions = [
             }
         ]
     },
+    {
+        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: "force_transfer_tokens",
         discriminator: [
@@ -2377,36 +2457,6 @@ var instructions = [
             }
         ]
     },
-    {
-        name: "jupiter_set_max_swap_slippage",
-        discriminator: [
-            110,
-            79,
-            13,
-            71,
-            208,
-            111,
-            56,
-            66
-        ],
-        accounts: [
-            {
-                name: "glam_state",
-                writable: true
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            }
-        ],
-        args: [
-            {
-                name: "slippage",
-                type: "u64"
-            }
-        ]
-    },
     {
         name: "jupiter_swap",
         discriminator: [
@@ -2827,67 +2877,6 @@ var instructions = [
             }
         ]
     },
-    {
-        name: "jupiter_vote_merge_partial_unstaking",
-        discriminator: [
-            93,
-            226,
-            122,
-            120,
-            130,
-            35,
-            189,
-            208
-        ],
-        accounts: [
-            {
-                name: "glam_state"
-            },
-            {
-                name: "glam_vault",
-                pda: {
-                    seeds: [
-                        {
-                            kind: "const",
-                            value: [
-                                118,
-                                97,
-                                117,
-                                108,
-                                116
-                            ]
-                        },
-                        {
-                            kind: "account",
-                            path: "glam_state"
-                        }
-                    ]
-                }
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            },
-            {
-                name: "cpi_program",
-                address: "voTpe3tHQ7AjQHMapgSue2HJFAh2cGsdokqN3XqmVSj"
-            },
-            {
-                name: "locker",
-                writable: true
-            },
-            {
-                name: "escrow",
-                writable: true
-            },
-            {
-                name: "partial_unstake",
-                writable: true
-            }
-        ],
-        args: []
-    },
     {
         name: "jupiter_vote_new_escrow",
         discriminator: [
@@ -2954,81 +2943,6 @@ var instructions = [
         ],
         args: []
     },
-    {
-        name: "jupiter_vote_open_partial_unstaking",
-        discriminator: [
-            84,
-            7,
-            113,
-            220,
-            212,
-            63,
-            237,
-            218
-        ],
-        accounts: [
-            {
-                name: "glam_state"
-            },
-            {
-                name: "glam_vault",
-                pda: {
-                    seeds: [
-                        {
-                            kind: "const",
-                            value: [
-                                118,
-                                97,
-                                117,
-                                108,
-                                116
-                            ]
-                        },
-                        {
-                            kind: "account",
-                            path: "glam_state"
-                        }
-                    ]
-                }
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            },
-            {
-                name: "cpi_program",
-                address: "voTpe3tHQ7AjQHMapgSue2HJFAh2cGsdokqN3XqmVSj"
-            },
-            {
-                name: "locker",
-                writable: true
-            },
-            {
-                name: "escrow",
-                writable: true
-            },
-            {
-                name: "partial_unstake",
-                writable: true,
-                signer: true
-            },
-            {
-                name: "system_program",
-                address: "11111111111111111111111111111111"
-            }
-        ],
-        args: [
-            {
-                name: "amount",
-                type: "u64"
-            },
-            {
-                name: "memo",
-                type: "string"
-            }
-        ]
-    },
     {
         name: "jupiter_vote_toggle_max_lock",
         discriminator: [
@@ -3159,79 +3073,6 @@ var instructions = [
         ],
         args: []
     },
-    {
-        name: "jupiter_vote_withdraw_partial_unstaking",
-        discriminator: [
-            109,
-            98,
-            65,
-            252,
-            184,
-            0,
-            216,
-            240
-        ],
-        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: "voTpe3tHQ7AjQHMapgSue2HJFAh2cGsdokqN3XqmVSj"
-            },
-            {
-                name: "locker",
-                writable: true
-            },
-            {
-                name: "escrow",
-                writable: true
-            },
-            {
-                name: "partial_unstake",
-                writable: true
-            },
-            {
-                name: "escrow_tokens",
-                writable: true
-            },
-            {
-                name: "destination_tokens",
-                writable: true
-            },
-            {
-                name: "token_program"
-            }
-        ],
-        args: []
-    },
     {
         name: "kamino_farm_harvest_reward",
         discriminator: [
@@ -4097,7 +3938,8 @@ var instructions = [
         ],
         accounts: [
             {
-                name: "glam_state"
+                name: "glam_state",
+                writable: true
             },
             {
                 name: "glam_vault",
@@ -5941,8 +5783,90 @@ var instructions = [
                 writable: true,
                 signer: true
             },
+            {
+                name: "kamino_lending_program",
+                address: "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+            },
             {
                 name: "sol_oracle"
+            },
+            {
+                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
+                        ]
+                    }
+                }
+            },
+            {
+                name: "pyth_oracle",
+                optional: true
+            },
+            {
+                name: "switchboard_price_oracle",
+                optional: true
+            },
+            {
+                name: "switchboard_twap_oracle",
+                optional: true
+            },
+            {
+                name: "scope_prices",
+                optional: true
             }
         ],
         args: [
@@ -6001,6 +5925,68 @@ var instructions = [
             },
             {
                 name: "sol_oracle"
+            },
+            {
+                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: [
@@ -6051,14 +6037,76 @@ var instructions = [
                         }
                     ]
                 }
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            },
-            {
-                name: "sol_oracle"
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            },
+            {
+                name: "sol_oracle"
+            },
+            {
+                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: [
@@ -6117,6 +6165,68 @@ var instructions = [
             },
             {
                 name: "sol_oracle"
+            },
+            {
+                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: [
@@ -6175,6 +6285,68 @@ var instructions = [
             },
             {
                 name: "sol_oracle"
+            },
+            {
+                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: [
@@ -6625,80 +6797,6 @@ var instructions = [
             }
         ]
     },
-    {
-        name: "set_redemption_paused",
-        discriminator: [
-            226,
-            152,
-            104,
-            42,
-            1,
-            53,
-            196,
-            240
-        ],
-        accounts: [
-            {
-                name: "glam_state",
-                writable: true
-            },
-            {
-                name: "glam_mint"
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            }
-        ],
-        args: [
-            {
-                name: "mint_id",
-                type: "u8"
-            },
-            {
-                name: "paused",
-                type: "bool"
-            }
-        ]
-    },
-    {
-        name: "set_subscription_paused",
-        discriminator: [
-            220,
-            144,
-            129,
-            4,
-            136,
-            251,
-            85,
-            234
-        ],
-        accounts: [
-            {
-                name: "glam_state",
-                writable: true
-            },
-            {
-                name: "glam_mint"
-            },
-            {
-                name: "glam_signer",
-                writable: true,
-                signer: true
-            }
-        ],
-        args: [
-            {
-                name: "mint_id",
-                type: "u8"
-            },
-            {
-                name: "paused",
-                type: "bool"
-            }
-        ]
-    },
     {
         name: "set_token_accounts_states",
         discriminator: [
@@ -8867,6 +8965,44 @@ var instructions = [
             }
         ]
     },
+    {
+        name: "update_mint_apply_timelock",
+        discriminator: [
+            223,
+            241,
+            80,
+            24,
+            120,
+            25,
+            82,
+            134
+        ],
+        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: "update_state",
         discriminator: [
@@ -8901,6 +9037,31 @@ var instructions = [
             }
         ]
     },
+    {
+        name: "update_state_apply_timelock",
+        discriminator: [
+            66,
+            12,
+            138,
+            80,
+            133,
+            85,
+            46,
+            220
+        ],
+        accounts: [
+            {
+                name: "glam_state",
+                writable: true
+            },
+            {
+                name: "glam_signer",
+                writable: true,
+                signer: true
+            }
+        ],
+        args: []
+    },
     {
         name: "withdraw",
         discriminator: [
@@ -9075,6 +9236,19 @@ var instructions = [
     }
 ];
 var accounts = [
+    {
+        name: "GlobalConfig",
+        discriminator: [
+            149,
+            8,
+            156,
+            202,
+            160,
+            252,
+            176,
+            217
+        ]
+    },
     {
         name: "OpenfundsMetadataAccount",
         discriminator: [
@@ -9115,14 +9289,24 @@ var errors = [
     },
     {
         code: 48002,
-        name: "StateAccountDisabled",
-        msg: "State account is disabled"
+        name: "GlamStateDisabled",
+        msg: "GLAM state is disabled"
     },
     {
         code: 48003,
         name: "InvalidSignerAccount",
         msg: "Invalid signer token account"
     },
+    {
+        code: 48004,
+        name: "EmergencyUpdateDenied",
+        msg: "Emergency update denied"
+    },
+    {
+        code: 48005,
+        name: "TimelockStillActive",
+        msg: "Timelock still active"
+    },
     {
         code: 49000,
         name: "InvalidAccountType",
@@ -9268,6 +9452,11 @@ var errors = [
         name: "InvalidAmount",
         msg: "Invalid amount for subscription or redemption"
     },
+    {
+        code: 51007,
+        name: "MaxCapExceeded",
+        msg: "Max cap exceeded"
+    },
     {
         code: 51100,
         name: "InvalidPricingOracle",
@@ -9430,6 +9619,34 @@ var types = [
             ]
         }
     },
+    {
+        name: "AssetMeta",
+        type: {
+            kind: "struct",
+            fields: [
+                {
+                    name: "asset",
+                    type: "pubkey"
+                },
+                {
+                    name: "decimals",
+                    type: "u8"
+                },
+                {
+                    name: "oracle",
+                    type: "pubkey"
+                },
+                {
+                    name: "oracle_source",
+                    type: {
+                        defined: {
+                            name: "OracleSource"
+                        }
+                    }
+                }
+            ]
+        }
+    },
     {
         name: "BinLiquidityDistribution",
         type: {
@@ -9731,7 +9948,7 @@ var types = [
                     name: "ExternalVaultAccounts"
                 },
                 {
-                    name: "LockUp"
+                    name: "LockUpPeriod"
                 },
                 {
                     name: "DriftMarketIndexesPerp"
@@ -9764,7 +9981,7 @@ var types = [
                     name: "MinRedemption"
                 },
                 {
-                    name: "Valuation"
+                    name: "NotifyAndSettle"
                 },
                 {
                     name: "Ledger"
@@ -9785,7 +10002,49 @@ var types = [
                     name: "SubscriptionPaused"
                 },
                 {
-                    name: "RedemptionPaused"
+                    name: "RedemptionPaused"
+                },
+                {
+                    name: "Owner"
+                },
+                {
+                    name: "Enabled"
+                },
+                {
+                    name: "Name"
+                },
+                {
+                    name: "Uri"
+                },
+                {
+                    name: "Assets"
+                },
+                {
+                    name: "DelegateAcls"
+                },
+                {
+                    name: "Integrations"
+                },
+                {
+                    name: "UpdateTimelock"
+                },
+                {
+                    name: "TimelockExpiresAt"
+                },
+                {
+                    name: "DefaultAccountStateFrozen"
+                },
+                {
+                    name: "PermanentDelegate"
+                },
+                {
+                    name: "TimeUnit"
+                },
+                {
+                    name: "KaminoLendingMarkets"
+                },
+                {
+                    name: "MeteoraDlmmPools"
                 }
             ]
         }
@@ -9877,7 +10136,7 @@ var types = [
                     ]
                 },
                 {
-                    name: "Percentage",
+                    name: "U32",
                     fields: [
                         {
                             name: "val",
@@ -9995,13 +10254,56 @@ var types = [
                     ]
                 },
                 {
-                    name: "Valuation",
+                    name: "NotifyAndSettle",
+                    fields: [
+                        {
+                            name: "val",
+                            type: {
+                                defined: {
+                                    name: "NotifyAndSettle"
+                                }
+                            }
+                        }
+                    ]
+                },
+                {
+                    name: "VecDelegateAcl",
+                    fields: [
+                        {
+                            name: "val",
+                            type: {
+                                vec: {
+                                    defined: {
+                                        name: "DelegateAcl"
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                },
+                {
+                    name: "VecIntegration",
+                    fields: [
+                        {
+                            name: "val",
+                            type: {
+                                vec: {
+                                    defined: {
+                                        name: "Integration"
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                },
+                {
+                    name: "TimeUnit",
                     fields: [
                         {
                             name: "val",
                             type: {
                                 defined: {
-                                    name: "Valuation"
+                                    name: "TimeUnit"
                                 }
                             }
                         }
@@ -10417,6 +10719,51 @@ var types = [
             ]
         }
     },
+    {
+        name: "GlobalConfig",
+        type: {
+            kind: "struct",
+            fields: [
+                {
+                    name: "admin",
+                    docs: [
+                        "The authority that can modify the config"
+                    ],
+                    type: "pubkey"
+                },
+                {
+                    name: "fee_authority",
+                    docs: [
+                        "The authority that can modify fee structure of individual glam state",
+                        "and claim protocol fees"
+                    ],
+                    type: "pubkey"
+                },
+                {
+                    name: "referrer",
+                    type: "pubkey"
+                },
+                {
+                    name: "base_fee_bps",
+                    type: "u16"
+                },
+                {
+                    name: "flow_fee_bps",
+                    type: "u16"
+                },
+                {
+                    name: "asset_metas",
+                    type: {
+                        vec: {
+                            defined: {
+                                name: "AssetMeta"
+                            }
+                        }
+                    }
+                }
+            ]
+        }
+    },
     {
         name: "HurdleType",
         type: {
@@ -10775,9 +11122,15 @@ var types = [
                     }
                 },
                 {
-                    name: "lock_up_period_in_seconds",
+                    name: "lock_up_period",
                     type: {
-                        option: "i32"
+                        option: "u32"
+                    }
+                },
+                {
+                    name: "year_in_seconds",
+                    type: {
+                        option: "u32"
                     }
                 },
                 {
@@ -10803,23 +11156,19 @@ var types = [
                     }
                 },
                 {
-                    name: "fee_params",
+                    name: "notify_and_settle",
                     type: {
                         option: {
                             defined: {
-                                name: "FeeParams"
+                                name: "NotifyAndSettle"
                             }
                         }
                     }
                 },
                 {
-                    name: "valuation",
+                    name: "max_cap",
                     type: {
-                        option: {
-                            defined: {
-                                name: "Valuation"
-                            }
-                        }
+                        option: "u64"
                     }
                 },
                 {
@@ -10834,6 +11183,18 @@ var types = [
                         option: "u64"
                     }
                 },
+                {
+                    name: "subscription_paused",
+                    type: {
+                        option: "bool"
+                    }
+                },
+                {
+                    name: "redemption_paused",
+                    type: {
+                        option: "bool"
+                    }
+                },
                 {
                     name: "is_raw_openfunds",
                     type: {
@@ -11123,6 +11484,50 @@ var types = [
             ]
         }
     },
+    {
+        name: "NotifyAndSettle",
+        type: {
+            kind: "struct",
+            fields: [
+                {
+                    name: "model",
+                    type: {
+                        defined: {
+                            name: "ValuationModel"
+                        }
+                    }
+                },
+                {
+                    name: "notice_period",
+                    type: "u64"
+                },
+                {
+                    name: "notice_period_type",
+                    type: {
+                        defined: {
+                            name: "NoticePeriodType"
+                        }
+                    }
+                },
+                {
+                    name: "permissionless_fulfillment",
+                    type: "bool"
+                },
+                {
+                    name: "settlement_period",
+                    type: "u64"
+                },
+                {
+                    name: "cancellation_window",
+                    type: "u64"
+                },
+                {
+                    name: "_padding",
+                    type: "u8"
+                }
+            ]
+        }
+    },
     {
         name: "OpenfundsMetadataAccount",
         type: {
@@ -11179,6 +11584,68 @@ var types = [
             ]
         }
     },
+    {
+        name: "OracleSource",
+        type: {
+            kind: "enum",
+            variants: [
+                {
+                    name: "Pyth"
+                },
+                {
+                    name: "Switchboard"
+                },
+                {
+                    name: "QuoteAsset"
+                },
+                {
+                    name: "Pyth1K"
+                },
+                {
+                    name: "Pyth1M"
+                },
+                {
+                    name: "PythStableCoin"
+                },
+                {
+                    name: "Prelaunch"
+                },
+                {
+                    name: "PythPull"
+                },
+                {
+                    name: "Pyth1KPull"
+                },
+                {
+                    name: "Pyth1MPull"
+                },
+                {
+                    name: "PythStableCoinPull"
+                },
+                {
+                    name: "SwitchboardOnDemand"
+                },
+                {
+                    name: "PythLazer"
+                },
+                {
+                    name: "PythLazer1K"
+                },
+                {
+                    name: "PythLazer1M"
+                },
+                {
+                    name: "PythLazerStableCoin"
+                },
+                {
+                    name: "LstPoolState"
+                },
+                {
+                    name: "MarinadeState"
+                }
+            ]
+        }
+    },
     {
         name: "OrderParams",
         type: {
@@ -11472,6 +11939,9 @@ var types = [
                 },
                 {
                     name: "JupiterGovClaim"
+                },
+                {
+                    name: "EmergencyUpdate"
                 }
             ]
         }
@@ -12118,6 +12588,28 @@ var types = [
                         }
                     }
                 },
+                {
+                    name: "base_asset",
+                    type: {
+                        option: "pubkey"
+                    }
+                },
+                {
+                    name: "update_timelock",
+                    type: {
+                        option: "u32"
+                    }
+                },
+                {
+                    name: "time_unit",
+                    type: {
+                        option: {
+                            defined: {
+                                name: "TimeUnit"
+                            }
+                        }
+                    }
+                },
                 {
                     name: "delegate_acls",
                     type: {
@@ -12167,15 +12659,25 @@ var types = [
                     }
                 },
                 {
-                    name: "base_asset",
+                    name: "kamino_lending_markets",
                     type: {
-                        option: "pubkey"
+                        option: {
+                            vec: "pubkey"
+                        }
                     }
                 },
                 {
-                    name: "max_cap",
+                    name: "meteora_dlmm_pools",
                     type: {
-                        option: "u64"
+                        option: {
+                            vec: "pubkey"
+                        }
+                    }
+                },
+                {
+                    name: "max_swap_slippage_bps",
+                    type: {
+                        option: "u32"
                     }
                 },
                 {
@@ -12246,87 +12748,39 @@ var types = [
                     name: "CurveOneSide"
                 },
                 {
-                    name: "BidAskOneSide"
-                },
-                {
-                    name: "SpotBalanced"
-                },
-                {
-                    name: "CurveBalanced"
-                },
-                {
-                    name: "BidAskBalanced"
-                },
-                {
-                    name: "SpotImBalanced"
-                },
-                {
-                    name: "CurveImBalanced"
-                },
-                {
-                    name: "BidAskImBalanced"
-                }
-            ]
-        }
-    },
-    {
-        name: "TimeUnit",
-        type: {
-            kind: "enum",
-            variants: [
-                {
-                    name: "Slot"
-                },
-                {
-                    name: "Second"
-                }
-            ]
-        }
-    },
-    {
-        name: "Valuation",
-        type: {
-            kind: "struct",
-            fields: [
-                {
-                    name: "model",
-                    type: {
-                        defined: {
-                            name: "ValuationModel"
-                        }
-                    }
+                    name: "BidAskOneSide"
                 },
                 {
-                    name: "notice_period",
-                    type: "u64"
+                    name: "SpotBalanced"
                 },
                 {
-                    name: "notice_period_type",
-                    type: {
-                        defined: {
-                            name: "NoticePeriodType"
-                        }
-                    }
+                    name: "CurveBalanced"
                 },
                 {
-                    name: "permissionless_fulfillment",
-                    type: "bool"
+                    name: "BidAskBalanced"
                 },
                 {
-                    name: "settlement_period",
-                    type: "u64"
+                    name: "SpotImBalanced"
                 },
                 {
-                    name: "cancellation_window",
-                    type: "u64"
+                    name: "CurveImBalanced"
                 },
                 {
-                    name: "time_unit",
-                    type: {
-                        defined: {
-                            name: "TimeUnit"
-                        }
-                    }
+                    name: "BidAskImBalanced"
+                }
+            ]
+        }
+    },
+    {
+        name: "TimeUnit",
+        type: {
+            kind: "enum",
+            variants: [
+                {
+                    name: "Second"
+                },
+                {
+                    name: "Slot"
                 }
             ]
         }
@@ -12398,16 +12852,11 @@ function getGlamProgramId(cluster) {
     }
 }
 function getGlamProgram(cluster, provider) {
-    switch(cluster){
-        case "mainnet-beta":
-            return new anchor.Program(GlamIdl, provider);
-        default:
-            const idl = {
-                ...GlamProtocolIdlJson
-            };
-            idl.address = getGlamProgramId(cluster).toBase58();
-            return new anchor.Program(idl, provider);
-    }
+    const idl = {
+        ...GlamProtocolIdlJson
+    };
+    idl.address = getGlamProgramId(cluster).toBase58(); // Override program address for the specified cluster
+    return new anchor.Program(idl, provider);
 }
 
 const SEED_METADATA = (GlamProtocolIdlJson.constants.find((x)=>x.name === "SEED_METADATA")?.value || "").replace(/"/g, "");
@@ -12420,6 +12869,7 @@ const STAKE_ACCOUNT_SIZE = 200;
 const METEORA_POSITION_SIZE = 8120;
 const KAMINO_OBTRIGATION_SIZE = 3344;
 const JITO_TIP_DEFAULT = new web3_js.PublicKey("96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5");
+const KAMINO_SCOPE_PRICES = new web3_js.PublicKey("3NJYftD5sjVfxSnUdZ1wVML8f3aC6mp1CXCL6L7TnU8C");
 /**
  * Token mints. If no devnet version is defined, assume mainnet and devnet addresses are the same.
  *
@@ -12473,15 +12923,22 @@ class StateIdlModel {
         this.company = data.company ?? null;
         this.owner = data.owner ?? null;
         this.created = data.created ?? null;
+        // Configs
+        this.baseAsset = data.baseAsset ?? null;
+        this.updateTimelock = data.updateTimelock ?? null;
+        this.timeUnit = data.timeUnit ?? null;
+        // ACLs
         this.delegateAcls = data.delegateAcls ?? null;
         this.integrations = data.integrations ?? null;
+        // Integration specific configs
         this.driftMarketIndexesPerp = data.driftMarketIndexesPerp ?? null;
         this.driftMarketIndexesSpot = data.driftMarketIndexesSpot ?? null;
         this.driftOrderTypes = data.driftOrderTypes ?? null;
+        this.kaminoLendingMarkets = data.kaminoLendingMarkets ?? null;
+        this.meteoraDlmmPools = data.meteoraDlmmPools ?? null;
+        this.maxSwapSlippageBps = data.maxSwapSlippageBps ?? null;
         this.metadata = data.metadata ?? null;
         this.rawOpenfunds = data.rawOpenfunds ?? null;
-        this.baseAsset = data.baseAsset ?? null;
-        this.maxCap = data.maxCap ?? null;
     }
 }
 class StateModel extends StateIdlModel {
@@ -12531,7 +12988,7 @@ class StateModel extends StateIdlModel {
         return this.mintAddresses[0].toBase58() || this.idStr;
     }
     /**
-   * Build a StateModel from onchain accounts
+   * Build a StateModel from onchain data
    *
    * @param stateAccount provides core fund data
    * @param openfundsMetadataAccount includes fund rawOpenfunds data and share class rawOpenfunds data
@@ -12592,11 +13049,7 @@ class StateModel extends StateIdlModel {
                 const name = Object.keys(param.name)[0];
                 // @ts-ignore
                 const value = Object.values(param.value)[0].val;
-                if (name == "lockUp") {
-                    mintIdlModel["lockUpPeriodInSeconds"] = Number(value);
-                } else {
-                    mintIdlModel[name] = value;
-                }
+                mintIdlModel[name] = value;
             });
             if (openfundsMetadataAccount) {
                 const mintOpenfundsFields = {};
@@ -12671,18 +13124,24 @@ class MintIdlModel {
         this.rawOpenfunds = data.rawOpenfunds ?? null;
         this.allowlist = data.allowlist ?? null;
         this.blocklist = data.blocklist ?? null;
-        this.lockUpPeriodInSeconds = data.lockUpPeriodInSeconds ?? null;
+        this.lockUpPeriod = data.lockUpPeriod ?? null;
+        this.yearInSeconds = data.yearInSeconds ?? null;
         this.permanentDelegate = data.permanentDelegate ?? null;
         this.defaultAccountStateFrozen = data.defaultAccountStateFrozen ?? null;
         this.feeStructure = data.feeStructure ?? null;
         this.feeParams = data.feeParams ?? null;
-        this.valuation = data.valuation ?? null;
+        this.notifyAndSettle = data.notifyAndSettle ?? null;
+        this.maxCap = data.maxCap ?? null;
         this.minSubscription = data.minSubscription ?? null;
         this.minRedemption = data.minRedemption ?? null;
+        this.subscriptionPaused = data.subscriptionPaused ?? null;
+        this.redemptionPaused = data.redemptionPaused ?? null;
     }
 }
 class MintModel extends MintIdlModel {
-    static mintAddress(statePda, idx = 0, glamProgramId = GLAM_PROGRAM_ID_DEFAULT) {
+    /**
+   * @deprecated
+   */ static mintAddress(statePda, idx = 0, glamProgramId = GLAM_PROGRAM_ID_DEFAULT) {
         const [pda, _] = web3_js.PublicKey.findProgramAddressSync([
             Buffer.from(SEED_MINT),
             Uint8Array.from([
@@ -12778,6 +13237,14 @@ PriceDenom.SOL = {
 PriceDenom.USD = {
     usd: {}
 };
+class TimeUnit {
+}
+TimeUnit.Slot = {
+    slot: {}
+};
+TimeUnit.Second = {
+    second: {}
+};
 
 var ClusterNetwork = /*#__PURE__*/ function(ClusterNetwork) {
     ClusterNetwork["Mainnet"] = "mainnet-beta";
@@ -12878,6 +13345,30 @@ const parseMeteoraPosition = async (connection, position)=>{
         binArrayUpper
     };
 };
+async function fetchLookupTables(connection, authority, firstEntry) {
+    const ALT_PROGRAM_ID = new web3_js.PublicKey("AddressLookupTab1e1111111111111111111111111");
+    // Fetch all accounts owned by the ALT program
+    const accounts = await connection.getProgramAccounts(ALT_PROGRAM_ID, {
+        filters: [
+            {
+                memcmp: {
+                    offset: 22,
+                    bytes: authority.toBase58()
+                }
+            },
+            {
+                memcmp: {
+                    offset: 56,
+                    bytes: firstEntry.toBase58()
+                }
+            }
+        ]
+    });
+    return accounts.map(({ pubkey, account })=>new web3_js.AddressLookupTableAccount({
+            key: pubkey,
+            state: web3_js.AddressLookupTableAccount.deserialize(account.data)
+        }));
+}
 const getSimulationComputeUnits = async (connection, instructions, payer, lookupTables)=>{
     const testInstructions = [
         // Set an arbitrarily high number in simulation
@@ -13120,8 +13611,81 @@ class BlockhashWithCache {
     }
 }
 
+/**
+ * Compute state account PDA from state model
+ */ function getStatePda(stateModel, programId, owner) {
+    if (!stateModel?.created?.key && !stateModel?.name) {
+        throw new Error("State model must have created key or name");
+    }
+    const createdKey = stateModel?.created?.key || [
+        ...Buffer.from(anchor__namespace.utils.sha256.hash(stateModel?.name)).subarray(0, 8)
+    ];
+    const _owner = owner || stateModel?.owner?.pubkey;
+    if (!_owner) {
+        throw new Error("Owner must be specified explicitly or set in state model");
+    }
+    const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(SEED_STATE),
+        _owner.toBuffer(),
+        Uint8Array.from(createdKey)
+    ], programId);
+    return pda;
+}
+/**
+ * Compute vault PDA from state PDA
+ */ function getVaultPda(statePda, programId) {
+    const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(SEED_VAULT),
+        statePda.toBuffer()
+    ], programId);
+    return pda;
+}
+/**
+ * Compute escrow PDA from state PDA
+ */ function getEscrowPda(statePda, programId) {
+    const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(SEED_ESCROW),
+        statePda.toBuffer()
+    ], programId);
+    return pda;
+}
+function getOpenfundsPda(statePda, programId) {
+    const [pda, _] = web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(SEED_METADATA),
+        statePda.toBuffer()
+    ], programId);
+    return pda;
+}
+function getMintPda(statePda, mintIdx, programId) {
+    const [pda, _] = web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(SEED_MINT),
+        Uint8Array.from([
+            mintIdx % 256
+        ]),
+        statePda.toBuffer()
+    ], programId);
+    return pda;
+}
+function getExtraMetasPda(mint) {
+    return web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from("extra-account-metas"),
+        mint.toBuffer()
+    ], TRANSFER_HOOK_PROGRAM)[0];
+}
+function getAccountPolicyPda(tokenAccount) {
+    return web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from("account-policy"),
+        tokenAccount.toBuffer()
+    ], TRANSFER_HOOK_PROGRAM)[0];
+}
+
 const JUPITER_API_DEFAULT = "https://lite-api.jup.ag";
 const DEFAULT_PRIORITY_FEE = 10000; // microLamports
+const LOOKUP_TABLES = [
+    new web3_js.PublicKey("284iwGtA9X9aLy3KsyV8uT2pXLARhYbiSi5SiM2g47M2"),
+    new web3_js.PublicKey("D9cnvzswDikQDf53k4HpQ3KJ9y1Fv3HGGDFYMXnK5T6c"),
+    new web3_js.PublicKey("EiWSskK5HXnBTptiS5DH6gpAJRVNQ3cAhTKBGaiaysAb")
+];
 const isBrowser = process.env.ANCHOR_BROWSER || typeof window !== "undefined" && !window.process?.hasOwnProperty("type");
 class BaseClient {
     get detectedCluster() {
@@ -13134,6 +13698,15 @@ class BaseClient {
         }
         return ClusterNetwork.Mainnet;
     }
+    get statePda() {
+        if (!this._statePda) {
+            throw new Error("State PDA is not specified");
+        }
+        return this._statePda;
+    }
+    set statePda(statePda) {
+        this._statePda = statePda;
+    }
     isMainnet() {
         return this.cluster === ClusterNetwork.Mainnet;
     }
@@ -13192,7 +13765,7 @@ class BaseClient {
             })
         ];
     }
-    async intoVersionedTransaction(tx, { lookupTables, signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee = false, jitoTipLamports, simulate = false }) {
+    async intoVersionedTransaction(tx, { lookupTables = [], signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee = false, jitoTipLamports, simulate = false }) {
         signer = signer || this.getSigner();
         const instructions = tx.instructions;
         // Set Jito tip if provided
@@ -13203,6 +13776,7 @@ class BaseClient {
                 lamports: jitoTipLamports
             }));
         }
+        lookupTables.push(...await this.getAdressLookupTableAccounts(LOOKUP_TABLES));
         const recentBlockhash = (await this.blockhashWithCache.get()).blockhash;
         try {
             computeUnitLimit = await getSimulationComputeUnits(this.provider.connection, instructions, signer, lookupTables);
@@ -13296,13 +13870,13 @@ class BaseClient {
         }
         const addressLookupTableAccountInfos = await this.provider.connection.getMultipleAccountsInfo(keys.map((key)=>new web3_js.PublicKey(key)));
         return addressLookupTableAccountInfos.reduce((acc, accountInfo, index)=>{
-            const addressLookupTableAddress = keys[index];
+            const tableAddress = keys[index];
             if (accountInfo) {
-                const addressLookupTableAccount = new web3_js.AddressLookupTableAccount({
-                    key: new web3_js.PublicKey(addressLookupTableAddress),
+                const tableAccount = new web3_js.AddressLookupTableAccount({
+                    key: new web3_js.PublicKey(tableAddress),
                     state: web3_js.AddressLookupTableAccount.deserialize(accountInfo.data)
                 });
-                acc.push(addressLookupTableAccount);
+                acc.push(tableAccount);
             }
             return acc;
         }, new Array());
@@ -13313,44 +13887,33 @@ class BaseClient {
     getSigner() {
         const publicKey = this.provider?.publicKey;
         if (!publicKey) {
-            throw new Error("Signer public key cannot be retrieved from provider");
+            throw new Error("Signer public key cannot be retrieved from anchor provider");
         }
         return publicKey;
     }
-    getAta(mint, owner, tokenProgram = splToken.TOKEN_PROGRAM_ID) {
-        return splToken.getAssociatedTokenAddressSync(mint, owner, true, tokenProgram);
+    get signer() {
+        return this.getSigner();
     }
-    getStatePda(stateModel) {
-        const createdKey = stateModel?.created?.key || [
-            ...Buffer.from(anchor__namespace.utils.sha256.hash(this.getName(stateModel))).subarray(0, 8)
-        ];
-        const owner = stateModel.owner?.pubkey || this.getSigner();
-        const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from(SEED_STATE),
-            owner.toBuffer(),
-            Uint8Array.from(createdKey)
-        ], this.program.programId);
-        return pda;
+    get wallet() {
+        return this.getWallet();
     }
-    getVaultPda(statePda) {
-        const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from(SEED_VAULT),
-            statePda.toBuffer()
-        ], this.program.programId);
-        return pda;
+    get vaultPda() {
+        return getVaultPda(this.statePda, this.program.programId);
     }
-    getEscrowPda(statePda) {
-        const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from(SEED_ESCROW),
-            statePda.toBuffer()
-        ], this.program.programId);
-        return pda;
+    get escrowPda() {
+        return getEscrowPda(this.statePda, this.program.programId);
+    }
+    get mintPda() {
+        return getMintPda(this.statePda, 0, this.program.programId);
     }
-    getVaultAta(glamState, mint, programId) {
-        return this.getAta(mint, this.getVaultPda(glamState), programId);
+    get extraMetasPda() {
+        return getExtraMetasPda(this.mintPda);
+    }
+    get openfundsPda() {
+        return getOpenfundsPda(this.statePda, this.program.programId);
     }
     /**
-   * Fetch all the token accounts (including token program and token 2022 program) owned by a public key.
+   * Fetch all the token accounts (including token program and token 2022 program) owned by the specified account.
    *
    * @param owner
    * @returns
@@ -13381,128 +13944,122 @@ class BaseClient {
                 programId: splToken.TOKEN_2022_PROGRAM_ID
             })));
     }
-    async getVaultBalance(statePda) {
-        const vault = this.getVaultPda(statePda);
-        const lamports = await this.provider.connection.getBalance(vault);
+    async getSolAndTokenBalances(owner) {
+        const balanceLamports = await this.provider.connection.getBalance(owner);
+        const tokenAccounts = await this.getTokenAccountsByOwner(owner);
+        const uiAmount = balanceLamports / web3_js.LAMPORTS_PER_SOL;
+        return {
+            balanceLamports,
+            uiAmount,
+            tokenAccounts
+        };
+    }
+    getAta(mint, owner, tokenProgram = splToken.TOKEN_PROGRAM_ID) {
+        return splToken.getAssociatedTokenAddressSync(mint, owner, true, tokenProgram);
+    }
+    getVaultAta(mint, tokenProgramId) {
+        return this.getAta(mint, this.vaultPda, tokenProgramId);
+    }
+    async getVaultBalance() {
+        const lamports = await this.provider.connection.getBalance(this.vaultPda);
         return lamports / web3_js.LAMPORTS_PER_SOL;
     }
-    async getVaultTokenBalance(glamState, mint, programId) {
-        const ata = this.getVaultAta(glamState, mint);
-        const _mint = await splToken.getMint(this.provider.connection, mint);
+    async getVaultLamports() {
+        return await this.provider.connection.getBalance(this.vaultPda);
+    }
+    async getVaultTokenBalance(mintPubkey) {
+        const { mint, tokenProgram } = await this.fetchMintAndTokenProgram(mintPubkey);
+        const ata = this.getVaultAta(mintPubkey, tokenProgram);
         try {
-            const account = await splToken.getAccount(this.provider.connection, ata);
-            return Number(account.amount) / Math.pow(10, _mint.decimals);
+            const account = await splToken.getAccount(this.provider.connection, ata, "confirmed", tokenProgram);
+            return {
+                amount: new anchor.BN(account.amount),
+                uiAmount: Number(account.amount) / Math.pow(10, mint.decimals)
+            };
         } catch (e) {
             if (e instanceof splToken.TokenAccountNotFoundError) {
-                return 0;
+                return {
+                    amount: new anchor.BN(0),
+                    uiAmount: 0
+                };
             }
             throw e;
         }
     }
-    async fetchMintWithOwner(asset) {
+    async fetchMintAndTokenProgram(mintPubkey) {
         const connection = this.provider.connection;
-        const info = await connection.getAccountInfo(asset, "confirmed");
+        const info = await connection.getAccountInfo(mintPubkey, "confirmed");
         if (!info) {
-            throw new Error(`Mint ${asset.toBase58()} not found`);
+            throw new Error(`Mint ${mintPubkey} not found`);
         }
         const tokenProgram = info.owner;
-        const mint = splToken.unpackMint(asset, info, tokenProgram);
+        const mint = splToken.unpackMint(mintPubkey, info, tokenProgram);
         return {
             mint,
             tokenProgram
         };
     }
-    getOpenfundsPda(statePda) {
-        const [pda, _] = web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from(SEED_METADATA),
-            statePda.toBuffer()
-        ], this.program.programId);
-        return pda;
-    }
-    getMintPda(statePda, mintIdx = 0) {
-        const [pda, _] = web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from(SEED_MINT),
-            Uint8Array.from([
-                mintIdx % 256
-            ]),
-            statePda.toBuffer()
-        ], this.program.programId);
-        return pda;
-    }
-    getMintAta(user, mintPda) {
-        return this.getAta(mintPda, user, splToken.TOKEN_2022_PROGRAM_ID);
-    }
-    getExtraMetasPda(glamState, mintIdx = 0) {
-        const mintPda = this.getMintPda(glamState, mintIdx);
-        return web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from("extra-account-metas"),
-            mintPda.toBuffer()
-        ], TRANSFER_HOOK_PROGRAM)[0];
-    }
-    getAccountPolicyPda(glamState, subject, mintIdx = 0) {
-        const ata = this.getMintAta(subject, this.getMintPda(glamState, mintIdx));
-        return web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from("account-policy"),
-            ata.toBuffer()
-        ], TRANSFER_HOOK_PROGRAM)[0];
+    getMintAta(user) {
+        return this.getAta(this.mintPda, user, splToken.TOKEN_2022_PROGRAM_ID);
     }
-    getName(stateModel) {
+    /**
+   * @deprecated
+   */ getName(stateModel) {
         const name = stateModel.name || stateModel.mints && stateModel.mints[0]?.name || stateModel.rawOpenfunds?.legalFundNameIncludingUmbrella;
         if (!name) {
             throw new Error("Name not be inferred from state model");
         }
         return name;
     }
-    async isLockupEnabled(statePda, mintIdx = 0) {
-        // @ts-ignore
-        const state = await this.fetchStateAccount(statePda);
-        if (state.params.length <= 1 + mintIdx) {
+    async isLockupEnabled() {
+        if (!this.statePda) {
+            throw new Error("State PDA is not specified");
+        }
+        const state = await this.fetchStateAccount();
+        if (state.params.length < 2) {
             throw new Error("Invalid mint index");
         }
-        for (const param of state.params[1 + mintIdx]){
+        // iterate over the mint params
+        for (const param of state.params[1]){
             const name = Object.keys(param.name)[0];
             // @ts-ignore
             const value = Object.values(param.value)[0].val;
-            if (name === "lockUp") {
+            if (name === "lockUpPeriod") {
                 return new anchor.BN(value).toNumber() >= 0;
             }
         }
         return false;
     }
     async fetchStateAccount(statePda) {
-        return await this.program.account.stateAccount.fetch(statePda);
+        return await this.program.account.stateAccount.fetch(statePda || this.statePda);
     }
-    async fetchOpenfundsMetadataAccount(state) {
-        const openfunds = this.getOpenfundsPda(state);
-        return await this.program.account.openfundsMetadataAccount.fetch(openfunds);
-    }
-    async fetchMintAccount(state, mintIdx) {
-        const connection = this.provider.connection;
-        return await splToken.getMint(connection, this.getMintPda(state, mintIdx), connection.commitment, splToken.TOKEN_2022_PROGRAM_ID);
+    async fetchOpenfundsMetadataAccount(statePda) {
+        const glamStatePda = statePda || this.statePda; // state pda used for computing openfunds pda
+        const openfundsPda = glamStatePda.equals(this.statePda) ? this.openfundsPda : getOpenfundsPda(glamStatePda, this.program.programId);
+        return await this.program.account.openfundsMetadataAccount.fetch(openfundsPda);
     }
     /**
    * Generates instructions to wrap SOL into wSOL if the vault doesn't have enough wSOL
    *
    * @param lamports Desired amount of wSOL
    * @returns Array of instructions, null if no instructions are needed
-   */ async maybeWrapSol(glamState, lamports, signer) {
+   */ async maybeWrapSol(lamports, signer) {
         const glamSigner = signer || this.getSigner();
-        const glamVault = this.getVaultPda(glamState);
-        const vaultWsolAta = this.getAta(WSOL, glamVault);
+        const vaultWsolAta = this.getAta(WSOL, this.vaultPda);
         let wsolBalance = new anchor.BN(0);
         try {
             wsolBalance = new anchor.BN((await this.provider.connection.getTokenAccountBalance(vaultWsolAta)).value.amount);
         } catch (err) {}
-        const solBalance = new anchor.BN(await this.provider.connection.getBalance(glamVault));
+        const solBalance = new anchor.BN(await this.provider.connection.getBalance(this.vaultPda));
         const delta = new anchor.BN(lamports).sub(wsolBalance); // wSOL amount needed
         if (solBalance.lt(delta)) {
             throw new Error(`Insufficient funds in vault to complete the transaction. SOL balance (lamports): ${solBalance}, lamports needed: ${lamports}`);
         }
         if (delta.gt(new anchor.BN(0)) && solBalance.gte(delta)) {
             return [
-                splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultWsolAta, glamVault, WSOL),
+                splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultWsolAta, this.vaultPda, WSOL),
                 await this.program.methods.systemTransfer(delta).accounts({
-                    glamState,
+                    glamState: this.statePda,
                     glamSigner,
                     to: vaultWsolAta
                 }).instruction(),
@@ -13511,7 +14068,9 @@ class BaseClient {
         }
         return [];
     }
-    getAssetIdFromCurrency(currency) {
+    /**
+   * @deprecated
+   */ getAssetIdFromCurrency(currency) {
         switch(currency.toUpperCase()){
             case "SOL":
             case "WSOL":
@@ -13548,19 +14107,21 @@ class BaseClient {
     /**
    * Fetch glam state from onchain accounts and build a StateModel
    *
-   * @param statePda
+   * @param statePda Optional state PDA, if not specified, use the client's state PDA
    * @returns
-   */ async fetchState(statePda) {
-        const stateAccount = await this.fetchStateAccount(statePda);
-        const openfundsMetadataAccount = await this.fetchOpenfundsMetadataAccount(statePda);
+   */ async fetchStateModel(statePda) {
+        const glamStatePda = statePda || this.statePda;
+        const stateAccount = await this.fetchStateAccount(glamStatePda);
+        const openfundsMetadataAccount = await this.fetchOpenfundsMetadataAccount(glamStatePda);
         if (stateAccount.mints.length > 0) {
-            const firstMint = await this.fetchMintAccount(statePda, 0);
-            return StateModel.fromOnchainAccounts(statePda, stateAccount, openfundsMetadataAccount, firstMint, this.program.programId);
+            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(statePda, stateAccount, openfundsMetadataAccount, undefined, this.program.programId);
     }
     /**
-   * Fetch all glam states if no filter options provided
+   * Fetch all glam state models if no filter options provided
    *
    * @param filterOptions
    * @returns
@@ -13604,6 +14165,9 @@ class BaseClient {
         }
         this.cluster = config?.cluster || this.detectedCluster;
         this.program = getGlamProgram(this.cluster, this.provider);
+        if (config?.statePda) {
+            this.statePda = config.statePda;
+        }
         this.jupiterApi = config?.jupiterApi || JUPITER_API_DEFAULT;
         this.blockhashWithCache = new BlockhashWithCache(this.provider, !!isBrowser);
     }
@@ -14508,56 +15072,52 @@ const DRIFT_MARGIN_PRECISION = 10000;
 class DriftClient {
     /*
    * Client methods
-   */ async initialize(statePda, subAccountId = 0, txOptions = {}) {
-        const tx = await this.initializeTx(new web3_js.PublicKey(statePda), subAccountId, txOptions);
-        return await this.base.sendAndConfirm(tx);
-    }
-    async updateUserCustomMarginRatio(statePda, maxLeverage, subAccountId = 0) {
-        const tx = await this.updateUserCustomMarginRatioTx(statePda, maxLeverage, subAccountId);
+   */ async initialize(subAccountId = 0, txOptions = {}) {
+        const tx = await this.initializeTx(subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async updateUserMarginTradingEnabled(statePda, marginTradingEnabled, subAccountId = 0, txOptions = {}) {
-        const tx = await this.updateUserMarginTradingEnabledTx(statePda, marginTradingEnabled, subAccountId, txOptions);
+    async updateUserCustomMarginRatio(maxLeverage, subAccountId = 0) {
+        const tx = await this.updateUserCustomMarginRatioTx(maxLeverage, subAccountId);
         return await this.base.sendAndConfirm(tx);
     }
-    async updateUserDelegate(statePda, delegate, subAccountId = 0) {
-        const tx = await this.updateUserDelegateTx(new web3_js.PublicKey(statePda), new web3_js.PublicKey(delegate), subAccountId);
+    async updateUserMarginTradingEnabled(marginTradingEnabled, subAccountId = 0, txOptions = {}) {
+        const tx = await this.updateUserMarginTradingEnabledTx(marginTradingEnabled, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async deleteUser(statePda, subAccountId = 0, txOptions = {}) {
-        const tx = await this.deleteUserTx(new web3_js.PublicKey(statePda), subAccountId, txOptions);
+    async updateUserDelegate(delegate, subAccountId = 0) {
+        const tx = await this.updateUserDelegateTx(new web3_js.PublicKey(delegate), subAccountId);
         return await this.base.sendAndConfirm(tx);
     }
-    async deposit(statePda, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
-        const tx = await this.depositTx(new web3_js.PublicKey(statePda), amount, marketIndex, subAccountId, txOptions);
+    async deleteUser(subAccountId = 0, txOptions = {}) {
+        const tx = await this.deleteUserTx(subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async withdraw(statePda, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
-        const tx = await this.withdrawTx(new web3_js.PublicKey(statePda), amount, marketIndex, subAccountId, txOptions);
+    async deposit(amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
+        const tx = await this.depositTx(amount, marketIndex, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async placeOrder(statePda, orderParams, subAccountId = 0, txOptions = {}) {
-        const tx = await this.placeOrderTx(new web3_js.PublicKey(statePda), orderParams, subAccountId, txOptions);
+    async withdraw(amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
+        const tx = await this.withdrawTx(amount, marketIndex, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async modifyOrder(statePda, modifyOrderParams, subAccountId = 0, txOptions = {}) {
-        const tx = await this.modifyOrderTx(new web3_js.PublicKey(statePda), modifyOrderParams, subAccountId, txOptions);
+    async placeOrder(orderParams, subAccountId = 0, txOptions = {}) {
+        const tx = await this.placeOrderTx(orderParams, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async cancelOrders(statePda, marketType, marketIndex, direction, subAccountId = 0, txOptions = {}) {
-        const tx = await this.cancelOrdersTx(new web3_js.PublicKey(statePda), marketType, marketIndex, direction, subAccountId, txOptions);
+    async modifyOrder(modifyOrderParams, subAccountId = 0, txOptions = {}) {
+        const tx = await this.modifyOrderTx(modifyOrderParams, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async cancelOrdersByIds(statePda, orderIds, subAccountId = 0, txOptions = {}) {
-        const tx = await this.cancelOrdersByIdsTx(new web3_js.PublicKey(statePda), orderIds, subAccountId, txOptions);
+    async cancelOrders(marketType, marketIndex, direction, subAccountId = 0, txOptions = {}) {
+        const tx = await this.cancelOrdersTx(marketType, marketIndex, direction, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async settlePnl(statePda, marketIndex, subAccountId = 0, txOptions = {}) {
-        const tx = await this.settlePnlTx(new web3_js.PublicKey(statePda), marketIndex, subAccountId, txOptions);
+    async cancelOrdersByIds(orderIds, subAccountId = 0, txOptions = {}) {
+        const tx = await this.cancelOrdersByIdsTx(orderIds, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async priceDrift(statePda, priceDenom, txOptions = {}) {
-        const tx = await this.priceDriftTx(new web3_js.PublicKey(statePda), priceDenom, txOptions);
+    async settlePnl(marketIndex, subAccountId = 0, txOptions = {}) {
+        const tx = await this.settlePnlTx(marketIndex, subAccountId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     getGlamReferrerPdas() {
@@ -14623,8 +15183,8 @@ class DriftClient {
             uiAmount
         };
     }
-    getDriftUserPdas(statePda, subAccountId = 0) {
-        const vault = this.base.getVaultPda(new web3_js.PublicKey(statePda));
+    getDriftUserPdas(subAccountId = 0) {
+        const vault = this.base.vaultPda;
         return {
             user: this.getUserPda(vault, subAccountId),
             userStats: this.getUserStatsPda(vault)
@@ -14747,8 +15307,8 @@ class DriftClient {
     charsToName(chars) {
         return String.fromCharCode(...chars).replace(/\0/g, "").trim();
     }
-    async fetchDriftUser(statePda, subAccountId = 0) {
-        const { user } = this.getDriftUserPdas(new web3_js.PublicKey(statePda), subAccountId);
+    async fetchDriftUser(subAccountId = 0) {
+        const { user } = this.getDriftUserPdas(subAccountId);
         const accountInfo = await this.base.provider.connection.getAccountInfo(user);
         if (!accountInfo) {
             return null;
@@ -14792,8 +15352,10 @@ class DriftClient {
     //   const { spotPositions, perpPositions } = driftUser;
     //   return { spotPositions, perpPositions };
     // }
-    async fetchPolicyConfig(glamState) {
-        const driftUserAccount = glamState && glamState.id && await this.fetchDriftUser(glamState.id);
+    /**
+   * @deprecated
+   */ async fetchPolicyConfig(glamState) {
+        const driftUserAccount = glamState && glamState.id && await this.fetchDriftUser();
         let delegate = driftUserAccount?.delegate;
         if (delegate && delegate.equals(web3_js.PublicKey.default)) {
             delegate = undefined;
@@ -14808,8 +15370,8 @@ class DriftClient {
             driftMarketIndexesSpot: glamState?.driftMarketIndexesSpot || []
         };
     }
-    async composeRemainingAccounts(glamState, subAccountId, marketType, marketIndex) {
-        const driftUser = await this.fetchDriftUser(glamState, subAccountId);
+    async composeRemainingAccounts(subAccountId, marketType, marketIndex) {
+        const driftUser = await this.fetchDriftUser(subAccountId);
         if (!driftUser) {
             throw new Error("Drift user not found");
         }
@@ -14849,19 +15411,19 @@ class DriftClient {
                 isSigner: false
             })));
     }
-    async initializeUserStatsIx(glamState, glamSigner) {
-        const { userStats } = this.getDriftUserPdas(glamState);
+    async initializeUserStatsIx(glamSigner) {
+        const { userStats } = this.getDriftUserPdas();
         // @ts-ignore
         return await this.base.program.methods.driftInitializeUserStats().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             state: this.driftStatePda,
             userStats
         }).instruction();
     }
-    async initializeUserIx(glamState, glamSigner, subAccountId) {
+    async initializeUserIx(glamSigner, subAccountId) {
         const name = `GLAM *.+ ${subAccountId}`.split("").map((char)=>char.charCodeAt(0)).concat(Array(24).fill(0));
-        const { user, userStats } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user, userStats } = this.getDriftUserPdas(subAccountId);
         const { user: referrer, userStats: referrerStats } = this.getGlamReferrerPdas();
         const remainingAccounts = [
             {
@@ -14876,72 +15438,72 @@ class DriftClient {
             }
         ];
         return await this.base.program.methods.driftInitializeUser(subAccountId, name).accounts({
-            glamState,
+            glamState: this.base.statePda,
             user,
             userStats,
             state: this.driftStatePda,
             glamSigner
         }).remainingAccounts(remainingAccounts).instruction();
     }
-    async initializeTx(glamState, subAccountId = 0, txOptions = {}) {
+    async initializeTx(subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = new web3_js.Transaction();
         // Create userStats account if it doesn't exist
-        const { userStats } = this.getDriftUserPdas(glamState);
+        const { userStats } = this.getDriftUserPdas();
         const userStatsInfo = await this.base.provider.connection.getAccountInfo(userStats);
         if (!userStatsInfo) {
-            tx.add(await this.initializeUserStatsIx(glamState, glamSigner));
+            tx.add(await this.initializeUserStatsIx(glamSigner));
         }
         // Initialize user (aka sub-account)
-        tx.add(await this.initializeUserIx(glamState, glamSigner, subAccountId));
+        tx.add(await this.initializeUserIx(glamSigner, subAccountId));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async updateUserCustomMarginRatioIx(glamState, maxLeverage, subAccountId = 0, txOptions = {}) {
+    async updateUserCustomMarginRatioIx(maxLeverage, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        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;
         return await this.base.program.methods.driftUpdateUserCustomMarginRatio(subAccountId, marginRatio).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             user
         }).instruction();
     }
-    async updateUserCustomMarginRatioTx(glamState, maxLeverage, subAccountId = 0, txOptions = {}) {
-        const tx = new web3_js.Transaction().add(await this.updateUserCustomMarginRatioIx(glamState, maxLeverage, subAccountId, txOptions));
+    async updateUserCustomMarginRatioTx(maxLeverage, subAccountId = 0, txOptions = {}) {
+        const tx = new web3_js.Transaction().add(await this.updateUserCustomMarginRatioIx(maxLeverage, subAccountId, txOptions));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async updateUserMarginTradingEnabledIx(glamState, marginTradingEnabled, subAccountId = 0, txOptions = {}) {
+    async updateUserMarginTradingEnabledIx(marginTradingEnabled, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(subAccountId);
         return await this.base.program.methods.driftUpdateUserMarginTradingEnabled(subAccountId, marginTradingEnabled).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             user
         }).instruction();
     }
-    async updateUserMarginTradingEnabledTx(glamState, marginTradingEnabled, subAccountId = 0, txOptions = {}) {
-        const tx = new web3_js.Transaction().add(...txOptions.preInstructions || [], await this.updateUserMarginTradingEnabledIx(glamState, marginTradingEnabled, subAccountId, txOptions));
+    async updateUserMarginTradingEnabledTx(marginTradingEnabled, subAccountId = 0, txOptions = {}) {
+        const tx = new web3_js.Transaction().add(...txOptions.preInstructions || [], await this.updateUserMarginTradingEnabledIx(marginTradingEnabled, subAccountId, txOptions));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async updateUserDelegateIx(glamState, delegate, subAccountId = 0, txOptions = {}) {
+    async updateUserDelegateIx(delegate, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(subAccountId);
         return await this.base.program.methods.driftUpdateUserDelegate(subAccountId, new web3_js.PublicKey(delegate)).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             user
         }).instruction();
     }
-    async updateUserDelegateTx(glamState, delegate, subAccountId = 0, txOptions = {}) {
-        const tx = new web3_js.Transaction().add(await this.updateUserDelegateIx(glamState, delegate, subAccountId, txOptions));
+    async updateUserDelegateTx(delegate, subAccountId = 0, txOptions = {}) {
+        const tx = new web3_js.Transaction().add(await this.updateUserDelegateIx(delegate, subAccountId, txOptions));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async deleteUserTx(glamState, subAccountId = 0, txOptions = {}) {
+    async deleteUserTx(subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user, userStats } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user, userStats } = this.getDriftUserPdas(subAccountId);
         const tx = await this.base.program.methods.driftDeleteUser().accounts({
-            glamState,
+            glamState: this.base.statePda,
             state: this.driftStatePda,
             user,
             userStats,
@@ -14949,25 +15511,25 @@ class DriftClient {
         }).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async depositTx(glamState, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
+    async depositTx(amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user, userStats } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user, userStats } = this.getDriftUserPdas(subAccountId);
         const { mint, oracle, tokenProgram, marketPda, vault: driftVault } = await this.fetchAndParseSpotMarket(marketIndex);
         console.log(`Spot market ${marketIndex} mint ${mint}, oracle: ${oracle}, marketPda: ${marketPda}, vault: ${driftVault}`);
         const preInstructions = [];
         const postInstructions = [];
         // If drift user doesn't exist, prepend initializeUserStats and initializeUser instructions
-        if (!await this.fetchDriftUser(glamState, subAccountId)) {
-            preInstructions.push(await this.initializeUserStatsIx(glamState, glamSigner), await this.initializeUserIx(glamState, glamSigner, subAccountId));
+        if (!await this.fetchDriftUser(subAccountId)) {
+            preInstructions.push(await this.initializeUserStatsIx(glamSigner), await this.initializeUserIx(glamSigner, subAccountId));
         }
         if (mint.equals(WSOL)) {
-            const wrapSolIxs = await this.base.maybeWrapSol(glamState, amount, glamSigner);
+            const wrapSolIxs = await this.base.maybeWrapSol(amount, glamSigner);
             preInstructions.push(...wrapSolIxs);
             // If we need to wrap SOL, it means the wSOL balance will be drained,
             // and we close the wSOL token account for convenience
-            const tokenAccount = this.base.getVaultAta(glamState, WSOL);
+            const tokenAccount = this.base.getVaultAta(WSOL);
             const closeTokenAccountIx = await this.base.program.methods.tokenCloseAccount().accounts({
-                glamState,
+                glamState: this.base.statePda,
                 glamSigner,
                 tokenAccount,
                 cpiProgram: splToken.TOKEN_PROGRAM_ID
@@ -14994,24 +15556,24 @@ class DriftClient {
             });
         }
         const tx = await this.base.program.methods.driftDeposit(marketIndex, amount, false).accounts({
-            glamState,
+            glamState: this.base.statePda,
             state: this.driftStatePda,
             user,
             userStats,
             spotMarketVault: driftVault,
-            userTokenAccount: this.base.getVaultAta(glamState, mint, tokenProgram),
+            userTokenAccount: this.base.getVaultAta(mint, tokenProgram),
             glamSigner,
             tokenProgram
         }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async withdrawTx(statePda, amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
+    async withdrawTx(amount, marketIndex = 1, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user, userStats } = this.getDriftUserPdas(statePda, subAccountId);
+        const { user, userStats } = this.getDriftUserPdas(subAccountId);
         const { mint, tokenProgram, vault: driftVault } = await this.fetchAndParseSpotMarket(marketIndex);
-        const glamVault = this.base.getVaultPda(statePda);
-        const glamVaultAta = this.base.getVaultAta(statePda, mint, tokenProgram);
-        const remainingAccounts = await this.composeRemainingAccounts(statePda, subAccountId, MarketType.SPOT, marketIndex);
+        const glamVault = this.base.vaultPda;
+        const glamVaultAta = this.base.getVaultAta(mint, tokenProgram);
+        const remainingAccounts = await this.composeRemainingAccounts(subAccountId, MarketType.SPOT, marketIndex);
         if (tokenProgram.equals(splToken.TOKEN_2022_PROGRAM_ID)) {
             remainingAccounts.push({
                 pubkey: mint,
@@ -15024,7 +15586,7 @@ class DriftClient {
             splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, glamVaultAta, glamVault, mint, tokenProgram)
         ];
         const tx = await this.base.program.methods.driftWithdraw(marketIndex, amount, false).accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             state: this.driftStatePda,
             user,
             userStats,
@@ -15036,10 +15598,10 @@ class DriftClient {
         }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async placeOrderTx(glamState, orderParams, subAccountId = 0, txOptions = {}) {
+    async placeOrderTx(orderParams, subAccountId = 0, txOptions = {}) {
         const { marketIndex, marketType } = orderParams;
         const { user: referrer, userStats: referrerStats } = this.getGlamReferrerPdas();
-        const remainingAccounts = (await this.composeRemainingAccounts(glamState, subAccountId, marketType, marketIndex)).concat([
+        const remainingAccounts = (await this.composeRemainingAccounts(subAccountId, marketType, marketIndex)).concat([
             {
                 pubkey: referrer,
                 isWritable: true,
@@ -15052,19 +15614,19 @@ class DriftClient {
             }
         ]);
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(subAccountId);
         // @ts-ignore
         const tx = await this.base.program.methods.driftPlaceOrders([
             orderParams
         ]).accounts({
-            glamState,
+            glamState: this.base.statePda,
             user,
             state: this.driftStatePda,
             glamSigner
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async modifyOrderTx(statePda, modifyOrderParams, subAccountId = 0, txOptions = {}) {
+    async modifyOrderTx(modifyOrderParams, subAccountId = 0, txOptions = {}) {
         // const { marketIndex, marketType } = orderParams;
         // const remainingAccounts = await this.composeRemainingAccounts(
         //   statePda,
@@ -15074,10 +15636,10 @@ class DriftClient {
         //   marketIndex,
         // );
         const signer = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(statePda, subAccountId);
+        const { user } = this.getDriftUserPdas(subAccountId);
         const tx = await this.base.program.methods// @ts-ignore
         .driftModifyOrder(1, modifyOrderParams).accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             glamSigner: signer,
             user,
             state: this.driftStatePda
@@ -15085,59 +15647,44 @@ class DriftClient {
         .transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async cancelOrdersTx(glamState, marketType, marketIndex, direction, subAccountId = 0, txOptions = {}) {
+    async cancelOrdersTx(marketType, marketIndex, direction, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
-        const remainingAccounts = await this.composeRemainingAccounts(glamState, subAccountId, marketType, marketIndex);
+        const { user } = this.getDriftUserPdas(subAccountId);
+        const remainingAccounts = await this.composeRemainingAccounts(subAccountId, marketType, marketIndex);
         // @ts-ignore
         const tx = await this.base.program.methods.driftCancelOrders(marketType, marketIndex, direction).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             user,
             state: this.driftStatePda
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async cancelOrdersByIdsTx(glamState, orderIds, subAccountId = 0, txOptions = {}) {
+    async cancelOrdersByIdsTx(orderIds, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
-        const remainingAccounts = await this.composeRemainingAccounts(glamState, subAccountId);
+        const { user } = this.getDriftUserPdas(subAccountId);
+        const remainingAccounts = await this.composeRemainingAccounts(subAccountId);
         // @ts-ignore
         const tx = await this.base.program.methods.driftCancelOrdersByIds(orderIds).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             user,
             state: this.driftStatePda
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async settlePnlTx(glamState, marketIndex, subAccountId = 0, txOptions = {}) {
+    async settlePnlTx(marketIndex, subAccountId = 0, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { user } = this.getDriftUserPdas(glamState, subAccountId);
-        const { vault: driftVault } = await this.fetchAndParseSpotMarket(marketIndex);
+        const { user } = this.getDriftUserPdas(subAccountId);
+        const { vault: driftVault } = await this.fetchAndParseSpotMarket(0);
+        const remainingAccounts = await this.composeRemainingAccounts(subAccountId, MarketType.PERP, marketIndex);
         // @ts-ignore
         const tx = await this.base.program.methods.driftSettlePnl(marketIndex).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             user,
             state: this.driftStatePda,
             spotMarketVault: driftVault
-        }).transaction();
-        return await this.base.intoVersionedTransaction(tx, txOptions);
-    }
-    async priceDriftTx(glamState, priceDenom, txOptions = {}) {
-        const signer = txOptions.signer || this.base.getSigner();
-        const glamVault = this.base.getVaultPda(glamState);
-        const { user, userStats } = this.getDriftUserPdas(glamState);
-        const remainingAccounts = await this.composeRemainingAccounts(glamState, 0);
-        const tx = await this.base.program.methods.priceDrift(priceDenom).accounts({
-            glamState,
-            signer,
-            glamVault,
-            user,
-            userStats,
-            solOracle: SOL_ORACLE,
-            state: this.driftStatePda
         }).remainingAccounts(remainingAccounts).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
@@ -15169,12 +15716,12 @@ const BASE = new web3_js.PublicKey("bJ1TRoFo2P6UHVwqdiipp6Qhp2HaaHpLowZ5LHet8Gm"
 class JupiterSwapClient {
     /*
    * Client methods
-   */ async swap(glamState, options, txOptions = {}) {
-        const tx = await this.swapTx(glamState, options, txOptions);
+   */ async swap(options, txOptions = {}) {
+        const tx = await this.swapTx(options, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async setMaxSwapSlippage(statePda, slippageBps, txOptions = {}) {
-        const tx = await this.setMaxSwapSlippageTx(statePda, slippageBps, txOptions);
+    async setMaxSwapSlippage(slippageBps, txOptions = {}) {
+        const tx = await this.setMaxSwapSlippageTx(slippageBps, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     async fetchProgramLabels() {
@@ -15189,9 +15736,9 @@ class JupiterSwapClient {
     }
     /*
    * API methods
-   */ async swapTx(glamState, options, txOptions = {}) {
+   */ async swapTx(options, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamVault = this.base.getVaultPda(glamState);
+        const glamVault = this.base.vaultPda;
         let swapInstruction;
         let addressLookupTableAddresses;
         let inputMint;
@@ -15237,10 +15784,10 @@ class JupiterSwapClient {
         ]);
         const inputStakePool = ASSETS_MAINNET.get(inputMint.toBase58())?.oracle || null;
         const outputStakePool = ASSETS_MAINNET.get(outputMint.toBase58())?.oracle || null;
-        const preInstructions = await this.getPreInstructions(glamState, glamSigner, inputMint, outputMint, amount, inputTokenProgram, outputTokenProgram);
+        const preInstructions = await this.getPreInstructions(glamSigner, inputMint, outputMint, amount, inputTokenProgram, outputTokenProgram);
         // @ts-ignore
         const tx = await this.base.program.methods.jupiterSwap(swapIx.data).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             inputMint,
             outputMint,
@@ -15254,22 +15801,19 @@ class JupiterSwapClient {
             ...txOptions
         });
     }
-    async setMaxSwapSlippageTx(glamState, slippageBps, txOptions = {}) {
-        const glamSigner = txOptions.signer || this.base.getSigner();
-        const tx = await this.base.program.methods.jupiterSetMaxSwapSlippage(new anchor.BN(slippageBps)).accounts({
-            glamState,
-            glamSigner
-        }).transaction();
+    async setMaxSwapSlippageTx(slippageBps, txOptions = {}) {
+        txOptions.signer || this.base.getSigner();
+        // FIXME: interface has changed, fix this place holder
+        const tx = new web3_js.Transaction();
         return this.base.intoVersionedTransaction(tx, {
             ...txOptions
         });
     }
-    async setMaxSwapSlippageIx(glamState, slippageBps, txOptions = {}) {
-        const glamSigner = txOptions.signer || this.base.getSigner();
-        return await this.base.program.methods.jupiterSetMaxSwapSlippage(new anchor.BN(slippageBps)).accounts({
-            glamState,
-            glamSigner
-        }).instruction();
+    async setMaxSwapSlippageIx(slippageBps, txOptions = {}) {
+        txOptions.signer || this.base.getSigner();
+        // FIXME: interface has changed, fix this place holder
+        const tx = new web3_js.Transaction();
+        return tx.instructions[0];
     }
     async getQuoteResponse(quoteParams) {
         const res = await fetch(`${this.base.jupiterApi}/swap/v1/quote?` + new URLSearchParams(Object.entries(quoteParams).map(([key, val])=>[
@@ -15300,15 +15844,15 @@ class JupiterSwapClient {
         this.base = base;
         this./*
    * Utils
-   */ getPreInstructions = async (statePda, signer, inputMint, outputMint, amount, inputTokenProgram = splToken.TOKEN_PROGRAM_ID, outputTokenProgram = splToken.TOKEN_PROGRAM_ID)=>{
-            const vault = this.base.getVaultPda(statePda);
-            const ata = this.base.getAta(outputMint, vault, outputTokenProgram);
+   */ getPreInstructions = async (signer, inputMint, outputMint, amount, inputTokenProgram = splToken.TOKEN_PROGRAM_ID, outputTokenProgram = splToken.TOKEN_PROGRAM_ID)=>{
+            const vault = this.base.vaultPda;
+            const ata = this.base.getVaultAta(outputMint, outputTokenProgram);
             const preInstructions = [
                 splToken.createAssociatedTokenAccountIdempotentInstruction(signer, ata, vault, outputMint, outputTokenProgram)
             ];
             // Transfer SOL to wSOL ATA if needed for the vault
             if (inputMint.equals(WSOL)) {
-                const wrapSolIxs = await this.base.maybeWrapSol(statePda, amount, signer);
+                const wrapSolIxs = await this.base.maybeWrapSol(amount, signer);
                 preInstructions.push(...wrapSolIxs);
             }
             return preInstructions;
@@ -15352,8 +15896,8 @@ class JupiterVoteClient {
    * @param amount
    * @param txOptions
    * @returns
-   */ async stakeJup(statePda, amount, txOptions = {}) {
-        const vault = this.base.getVaultPda(statePda);
+   */ async stakeJup(amount, txOptions = {}) {
+        const vault = this.base.vaultPda;
         const escrow = this.getEscrowPda(vault);
         const escrowJupAta = this.base.getAta(JUP, escrow);
         const vaultJupAta = this.base.getAta(JUP, vault);
@@ -15363,19 +15907,19 @@ class JupiterVoteClient {
         if (!escrowCreated) {
             console.log("Will create escrow account:", escrow.toBase58());
             preInstructions.push(await this.base.program.methods.jupiterVoteNewEscrow().accounts({
-                glamState: statePda,
+                glamState: this.base.statePda,
                 locker: this.stakeLocker,
                 escrow
             }).instruction());
             preInstructions.push(await this.base.program.methods.jupiterVoteToggleMaxLock(true).accounts({
-                glamState: statePda,
+                glamState: this.base.statePda,
                 locker: this.stakeLocker,
                 escrow
             }).instruction());
         }
         preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(this.base.getSigner(), escrowJupAta, escrow, JUP));
         const tx = await this.base.program.methods.jupiterVoteIncreaseLockedAmount(amount).accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             locker: this.stakeLocker,
             escrow,
             escrowTokens: escrowJupAta,
@@ -15394,11 +15938,11 @@ class JupiterVoteClient {
    * @param txOptions
    * @returns
    */ // TODO: support partial unstake
-    async unstakeJup(statePda, txOptions = {}) {
-        const vault = this.base.getVaultPda(statePda);
+    async unstakeJup(txOptions = {}) {
+        const vault = this.base.vaultPda;
         const escrow = this.getEscrowPda(vault);
         const tx = await this.base.program.methods.jupiterVoteToggleMaxLock(false).accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             locker: this.stakeLocker,
             escrow
         }).transaction();
@@ -15407,13 +15951,13 @@ class JupiterVoteClient {
         });
         return await this.base.sendAndConfirm(vTx);
     }
-    async withdrawJup(statePda, txOptions = {}) {
-        const vault = this.base.getVaultPda(statePda);
+    async withdrawJup(txOptions = {}) {
+        const vault = this.base.vaultPda;
         const escrow = this.getEscrowPda(vault);
         const escrowJupAta = this.base.getAta(JUP, escrow);
         const vaultJupAta = this.base.getAta(JUP, vault);
         const tx = await this.base.program.methods.jupiterVoteWithdraw().accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             locker: this.stakeLocker,
             escrow,
             escrowTokens: escrowJupAta,
@@ -15427,15 +15971,15 @@ class JupiterVoteClient {
         });
         return await this.base.sendAndConfirm(vTx);
     }
-    async claimAndStake(statePda, distributor, amountUnlocked, amountLocked, proof, txOptions = {}) {
+    async claimAndStake(distributor, amountUnlocked, amountLocked, proof, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(statePda);
+        const vault = this.base.vaultPda;
         const escrow = this.getEscrowPda(vault);
         const escrowJupAta = this.base.getAta(JUP, escrow);
         const distributorJupAta = this.base.getAta(JUP, distributor);
         // @ts-ignore
         const tx = await this.base.program.methods.merkleDistributorNewClaimAndStake(amountUnlocked, amountLocked, proof).accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             glamSigner,
             distributor,
             from: distributorJupAta,
@@ -15451,11 +15995,11 @@ class JupiterVoteClient {
         });
         return await this.base.sendAndConfirm(vTx);
     }
-    async cancelUnstake(statePda, txOptions = {}) {
-        const vault = this.base.getVaultPda(statePda);
+    async cancelUnstake(txOptions = {}) {
+        const vault = this.base.vaultPda;
         const escrow = this.getEscrowPda(vault);
         const tx = await this.base.program.methods.jupiterVoteToggleMaxLock(true).accounts({
-            glamState: statePda,
+            glamState: this.base.statePda,
             locker: this.stakeLocker,
             escrow
         }).transaction();
@@ -15467,13 +16011,12 @@ class JupiterVoteClient {
     /**
    * Vote on a proposal. The vote account will be created if it doesn't exist.
    *
-   * @param statePda
    * @param proposal
    * @param side
    * @param txOptions
    * @returns
-   */ async voteOnProposal(glamState, proposal, side, txOptions = {}) {
-        const glamVault = this.base.getVaultPda(glamState);
+   */ async voteOnProposal(proposal, side, txOptions = {}) {
+        const glamVault = this.base.vaultPda;
         const vote = this.getVotePda(proposal, glamVault);
         const governor = this.getGovernorPda();
         const voteAccountInfo = await this.base.provider.connection.getAccountInfo(vote);
@@ -15482,14 +16025,14 @@ class JupiterVoteClient {
         if (!voteCreated) {
             console.log("Will create vote account:", vote.toBase58());
             preInstructions.push(await this.base.program.methods.jupiterGovNewVote(glamVault).accountsPartial({
-                glamState,
+                glamState: this.base.statePda,
                 proposal,
                 vote
             }).instruction());
         }
         const escrow = this.getEscrowPda(glamVault);
         const tx = await this.base.program.methods.jupiterVoteCastVote(side).accounts({
-            glamState,
+            glamState: this.base.statePda,
             escrow,
             proposal,
             vote,
@@ -15504,8 +16047,8 @@ class JupiterVoteClient {
     }
     /*
    * Utils
-   */ async fetchVotes(glamState, proposals) {
-        const glamVault = this.base.getVaultPda(glamState);
+   */ async fetchVotes(proposals) {
+        const glamVault = this.base.vaultPda;
         const votes = proposals.map((proposal)=>this.getVotePda(new web3_js.PublicKey(proposal), glamVault));
         const votesAccountInfo = await this.base.provider.connection.getMultipleAccountsInfo(votes);
         return votesAccountInfo.filter((accountInfo)=>accountInfo !== null).map((accountInfo)=>({
@@ -15566,31 +16109,31 @@ class JupiterVoteClient {
 class MarinadeClient {
     /*
    * Client methods
-   */ async deposit(statePda, amount, txOptions = {}) {
-        const tx = await this.depositTx(statePda, amount, txOptions);
+   */ async deposit(amount, txOptions = {}) {
+        const tx = await this.depositTx(amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async depositStakeAccount(statePda, stakeAccount) {
-        const tx = await this.depositStakeAccountTx(statePda, stakeAccount, {});
+    async depositStakeAccount(stakeAccount) {
+        const tx = await this.depositStakeAccountTx(stakeAccount, {});
         return await this.base.sendAndConfirm(tx);
     }
-    async orderUnstake(statePda, amount, txOptions = {}) {
-        const tx = await this.orderUnstakeTx(statePda, amount, txOptions);
+    async orderUnstake(amount, txOptions = {}) {
+        const tx = await this.orderUnstakeTx(amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async claim(statePda, tickets, txOptions = {}) {
-        const tx = await this.claimTx(statePda, tickets, txOptions);
+    async claim(tickets, txOptions = {}) {
+        const tx = await this.claimTx(tickets, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /*
    * Utils
-   */ async getTickets(state) {
-        const vault = this.base.getVaultPda(state);
+   */ async getTickets() {
+        const vault = this.base.vaultPda;
         const accounts = await fetchMarinadeTicketAccounts(this.base.provider.connection, vault);
         return accounts.map((a)=>a.pubkey);
     }
-    async getParsedTickets(state) {
-        const vault = this.base.getVaultPda(state);
+    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)=>{
@@ -15643,15 +16186,15 @@ class MarinadeClient {
     }
     /*
    * API methods
-   */ async depositTx(glamState, amount, txOptions) {
+   */ async depositTx(amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const marinadeState = this.getMarinadeState();
-        const vaultMsolAta = this.base.getAta(marinadeState.msolMintAddress, vault);
+        const vaultMsolAta = this.base.getVaultAta(marinadeState.msolMintAddress);
         const createMsolAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultMsolAta, vault, marinadeState.msolMintAddress);
         // @ts-ignore
         const tx = await this.base.program.methods.marinadeDeposit(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             reservePda: marinadeState.reserveAddress,
             state: marinadeState.marinadeStateAddress,
@@ -15667,7 +16210,7 @@ class MarinadeClient {
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async depositStakeAccountTx(glamState, stakeAccount, txOptions) {
+    async depositStakeAccountTx(stakeAccount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const stakeAccountInfo = await this.getParsedStakeAccountInfo(stakeAccount);
         console.log("Stake account info", stakeAccountInfo);
@@ -15677,7 +16220,7 @@ class MarinadeClient {
         const validatorIndex = validatorLookupIndex === -1 ? marinadeState.state.validatorSystem.validatorList.count : validatorLookupIndex;
         const duplicationFlag = await marinadeState.validatorDuplicationFlag(stakeAccountInfo.voter);
         const tx = await this.base.program.methods.marinadeDepositStakeAccount(validatorIndex).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             state: marinadeState.marinadeStateAddress,
             validatorList: marinadeState.state.validatorSystem.validatorList.account,
@@ -15686,17 +16229,17 @@ class MarinadeClient {
             duplicationFlag,
             msolMint: MSOL,
             msolMintAuthority: await marinadeState.mSolMintAuthority(),
-            mintTo: this.base.getVaultAta(glamState, MSOL),
+            mintTo: this.base.getVaultAta(MSOL),
             clock: web3_js.SYSVAR_CLOCK_PUBKEY,
             tokenProgram: splToken.TOKEN_PROGRAM_ID,
             stakeProgram: web3_js.StakeProgram.programId
         }).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async orderUnstakeTx(glamState, amount, txOptions) {
+    async orderUnstakeTx(amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const marinadeState = this.getMarinadeState();
-        const vaultMsolAta = this.base.getVaultAta(glamState, marinadeState.msolMintAddress);
+        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);
@@ -15710,7 +16253,7 @@ class MarinadeClient {
             programId: MARINADE_PROGRAM_ID
         });
         const tx = await this.base.program.methods.marinadeOrderUnstake(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             newTicketAccount: ticket,
             msolMint: marinadeState.msolMintAddress,
@@ -15723,14 +16266,14 @@ class MarinadeClient {
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async claimTx(glamState, tickets, 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.getMarinadeState();
         const instructions = await Promise.all(tickets.map((ticket)=>this.base.program.methods.marinadeClaim().accounts({
-                glamState,
+                glamState: this.base.statePda,
                 glamSigner,
                 ticketAccount: ticket,
                 state: marinadeState.marinadeStateAddress,
@@ -15749,37 +16292,36 @@ class MarinadeClient {
 class WSolClient {
     /*
    * Client methods
-   */ async wrap(glamState, amount, txOptions = {}) {
-        const tx = await this.wrapTx(glamState, amount, txOptions);
+   */ async wrap(amount, txOptions = {}) {
+        const tx = await this.wrapTx(amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async unwrap(glamState, txOptions = {}) {
-        const tx = await this.unwrapTx(glamState, txOptions);
+    async unwrap(txOptions = {}) {
+        const tx = await this.unwrapTx(txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /*
    * API methods
-   */ async wrapTx(glamState, amount, txOptions) {
+   */ async wrapTx(amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
-        const to = this.base.getAta(WSOL, vault);
+        const to = this.base.getVaultAta(WSOL);
         // @ts-ignore
         const tx = await this.base.program.methods.systemTransfer(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             to
         }).preInstructions([
-            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, to, vault, WSOL)
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, to, this.base.vaultPda, WSOL)
         ]).postInstructions([
             splToken.createSyncNativeInstruction(to)
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async unwrapTx(glamState, txOptions) {
+    async unwrapTx(txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const tokenAccount = this.base.getVaultAta(glamState, WSOL);
+        const tokenAccount = this.base.getVaultAta(WSOL);
         const tx = await this.base.program.methods.tokenCloseAccount().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             tokenAccount,
             cpiProgram: splToken.TOKEN_PROGRAM_ID
@@ -15794,11 +16336,11 @@ class WSolClient {
 class StakingClient {
     /*
    * Client methods
-   */ async unstake(glamState, asset, amount, txOptions = {}) {
+   */ async unstake(asset, amount, txOptions = {}) {
         const assetStr = asset.toBase58();
         // mSOL
         if (assetStr === MSOL.toBase58()) {
-            const tx = await this.marinade.orderUnstakeTx(glamState, new anchor.BN(amount), txOptions);
+            const tx = await this.marinade.orderUnstakeTx(new anchor.BN(amount), txOptions);
             return await this.base.sendAndConfirm(tx);
         }
         // Other LSTs
@@ -15806,47 +16348,47 @@ class StakingClient {
         if (!assetMeta || !assetMeta.oracle) {
             throw new Error("Invalid LST: " + asset);
         }
-        const tx = await this.stakePoolWithdrawStakeTx(glamState, assetMeta.oracle, new anchor.BN(amount), true, txOptions);
+        const tx = await this.stakePoolWithdrawStakeTx(assetMeta.oracle, new anchor.BN(amount), true, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async stakePoolDepositSol(glamState, stakePool, amount, txOptions = {}) {
-        const tx = await this.stakePoolDepositSolTx(glamState, stakePool, amount, txOptions);
+    async stakePoolDepositSol(stakePool, amount, txOptions = {}) {
+        const tx = await this.stakePoolDepositSolTx(stakePool, amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async stakePoolDepositStake(glamState, stakePool, stakeAccount, txOptions = {}) {
-        const tx = await this.stakePoolDepositStakeTx(glamState, stakePool, stakeAccount, txOptions);
+    async stakePoolDepositStake(stakePool, stakeAccount, txOptions = {}) {
+        const tx = await this.stakePoolDepositStakeTx(stakePool, stakeAccount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async stakePoolWithdrawStake(glamState, stakePool, amount, txOptions = {}) {
-        const tx = await this.stakePoolWithdrawStakeTx(glamState, stakePool, amount, false, txOptions);
+    async stakePoolWithdrawStake(stakePool, amount, txOptions = {}) {
+        const tx = await this.stakePoolWithdrawStakeTx(stakePool, amount, false, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async initializeAndDelegateStake(glamState, vote, amount, txOptions = {}) {
-        const tx = await this.initializeAndDelegateStakeTx(glamState, vote, amount, txOptions);
+    async initializeAndDelegateStake(vote, amount, txOptions = {}) {
+        const tx = await this.initializeAndDelegateStakeTx(vote, amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async deactivate(glamState, stakeAccounts, txOptions = {}) {
-        const tx = await this.deactivateStakeTx(glamState, stakeAccounts, txOptions);
+    async deactivate(stakeAccounts, txOptions = {}) {
+        const tx = await this.deactivateStakeTx(stakeAccounts, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async withdraw(glamState, stakeAccounts, txOptions = {}) {
-        const tx = await this.withdrawStakeTx(glamState, stakeAccounts, txOptions);
+    async withdraw(stakeAccounts, txOptions = {}) {
+        const tx = await this.withdrawStakeTx(stakeAccounts, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async merge(glamState, destinationStake, sourceStake, txOptions = {}) {
-        const tx = await this.mergeStakeTx(glamState, destinationStake, sourceStake, txOptions);
+    async merge(destinationStake, sourceStake, txOptions = {}) {
+        const tx = await this.mergeStakeTx(destinationStake, sourceStake, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async split(glamState, existingStake, lamports, txOptions = {}) {
-        const { tx, newStake } = await this.splitStakeTx(glamState, existingStake, lamports, txOptions);
+    async split(existingStake, lamports, txOptions = {}) {
+        const { tx, newStake } = await this.splitStakeTx(existingStake, lamports, txOptions);
         const txSig = await this.base.sendAndConfirm(tx);
         return {
             newStake,
             txSig
         };
     }
-    async redelegate(glamState, existingStake, vote, txOptions = {}) {
-        const { newStake, tx } = await this.redelegateStakeTx(glamState, existingStake, vote, txOptions);
+    async redelegate(existingStake, vote, txOptions = {}) {
+        const { newStake, tx } = await this.redelegateStakeTx(existingStake, vote, txOptions);
         const txSig = await this.base.sendAndConfirm(tx);
         return {
             newStake,
@@ -15855,13 +16397,12 @@ class StakingClient {
     }
     /*
    * Utils
-   */ getStakeAccountPda(state, accountId) {
-        return web3_js.PublicKey.findProgramAddressSync([
-            Buffer.from("stake_account"),
-            Buffer.from(accountId),
-            state.toBuffer()
-        ], this.base.program.programId);
-    }
+   */ // getStakeAccountPda(state: PublicKey, accountId: string): [PublicKey, number] {
+    //   return PublicKey.findProgramAddressSync(
+    //     [Buffer.from("stake_account"), Buffer.from(accountId), state.toBuffer()],
+    //     this.base.program.programId,
+    //   );
+    // }
     getStakePoolWithdrawAuthority(programId, stakePool) {
         const [publicKey] = web3_js.PublicKey.findProgramAddressSync([
             stakePool.toBuffer(),
@@ -15877,6 +16418,7 @@ class StakingClient {
         return publicKey;
     }
     async getStakeAccountsWithStates(withdrawAuthority) {
+        const authority = withdrawAuthority || this.base.vaultPda;
         const accounts = await this.base.provider.connection.getParsedProgramAccounts(web3_js.StakeProgram.programId, {
             filters: [
                 {
@@ -15885,7 +16427,7 @@ class StakingClient {
                 {
                     memcmp: {
                         offset: 12,
-                        bytes: withdrawAuthority.toBase58()
+                        bytes: authority.toBase58()
                     }
                 }
             ]
@@ -15975,16 +16517,16 @@ class StakingClient {
     }
     /*
    * API methods
-   */ async stakePoolDepositSolTx(glamState, stakePool, lamports, txOptions = {}) {
+   */ async stakePoolDepositSolTx(stakePool, lamports, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { programId: stakePoolProgram, poolMint, withdrawAuthority, feeAccount, tokenProgramId: tokenProgram, reserveStake } = await this.getStakePoolAccountData(stakePool);
-        const glamVault = this.base.getVaultPda(glamState);
-        const poolTokensTo = this.base.getAta(poolMint, glamVault, tokenProgram);
+        const glamVault = this.base.vaultPda;
+        const poolTokensTo = this.base.getVaultAta(poolMint, tokenProgram);
         console.log(`stakePool ${stakePool}, programId: ${stakePoolProgram}`);
         // @ts-ignore
         const tx = await this.base.program.methods.stakePoolDepositSol(lamports).accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             cpiProgram: stakePoolProgram,
             stakePool,
             stakePoolWithdrawAuthority: withdrawAuthority,
@@ -15999,11 +16541,11 @@ class StakingClient {
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async stakePoolDepositStakeTx(glamState, stakePool, stakeAccount, txOptions = {}) {
+    async stakePoolDepositStakeTx(stakePool, stakeAccount, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { programId: stakePoolProgram, poolMint, depositAuthority, withdrawAuthority, feeAccount, validatorList, tokenProgramId: tokenProgram, reserveStake } = await this.getStakePoolAccountData(stakePool);
-        const glamVault = this.base.getVaultPda(glamState);
-        const poolTokensTo = this.base.getAta(poolMint, glamVault, tokenProgram);
+        const glamVault = this.base.vaultPda;
+        const poolTokensTo = this.base.getVaultAta(poolMint, tokenProgram);
         // All stake accounts owned by the stake pool withdraw authority
         const validatorStakeCandidates = await this.getStakeAccountsWithStates(withdrawAuthority);
         // Find a validator stake account to use from the list of candidates.
@@ -16018,7 +16560,7 @@ class StakingClient {
         }
         const tx = await this.base.program.methods.stakePoolDepositStake().accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             cpiProgram: stakePoolProgram,
             stakePool,
             stakePoolWithdrawAuthority: withdrawAuthority,
@@ -16036,11 +16578,11 @@ class StakingClient {
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async stakePoolWithdrawStakeTx(glamState, stakePool, amount, deactivate = false, txOptions = {}) {
+    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);
-        const glamVault = this.base.getVaultPda(glamState);
-        const poolTokensFrom = this.base.getAta(poolMint, glamVault, tokenProgram);
+        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 this.getStakeAccountsWithStates(withdrawAuthority)).filter((s)=>!s.address.equals(reserveStake));
         console.log("validatorStakeCandidates", validatorStakeCandidates);
@@ -16049,13 +16591,13 @@ class StakingClient {
         const postInstructions = deactivate ? [
             await this.base.program.methods.stakeDeactivate().accounts({
                 glamSigner,
-                glamState,
+                glamState: this.base.statePda,
                 stake: stakeAccount
             }).instruction()
         ] : [];
         const tx = await this.base.program.methods.stakePoolWithdrawStake(amount).accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             cpiProgram: stakePoolProgram,
             stake: stakeAccount,
             stakePool,
@@ -16071,21 +16613,21 @@ class StakingClient {
         ]).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async initializeAndDelegateStakeTx(glamState, vote, amount, txOptions = {}) {
+    async initializeAndDelegateStakeTx(vote, amount, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const [stakeAccount, createStakeAccountIx] = await this.createStakeAccount(glamSigner);
         const initStakeIx = await this.base.program.methods.stakeInitialize().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             stake: stakeAccount
         }).instruction();
         const fundStakeIx = await this.base.program.methods.systemTransfer(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             to: stakeAccount
         }).instruction();
         const tx = await this.base.program.methods.stakeDelegateStake().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             stake: stakeAccount,
             vote,
@@ -16097,13 +16639,13 @@ class StakingClient {
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async deactivateStakeTx(glamState, stakeAccounts, txOptions = {}) {
+    async deactivateStakeTx(stakeAccounts, txOptions = {}) {
         if (stakeAccounts.length < 1) {
             throw new Error("At least one stake account is required");
         }
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.program.methods.stakeDeactivate().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             stake: stakeAccounts[0]
         }).remainingAccounts(stakeAccounts.slice(1).map((a)=>({
@@ -16113,7 +16655,7 @@ class StakingClient {
             }))).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async withdrawStakeTx(glamState, stakeAccounts, txOptions = {}) {
+    async withdrawStakeTx(stakeAccounts, txOptions = {}) {
         if (stakeAccounts.length < 1) {
             throw new Error("At least one stake account is required");
         }
@@ -16125,7 +16667,7 @@ class StakingClient {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.program.methods.stakeWithdraw(lamports).accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             stake: stakeAccounts[0]
         }).remainingAccounts(stakeAccounts.slice(1).map((a)=>({
                 pubkey: a,
@@ -16134,22 +16676,22 @@ class StakingClient {
             }))).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async mergeStakeTx(glamState, destinationStake, sourceStake, txOptions = {}) {
+    async mergeStakeTx(destinationStake, sourceStake, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.program.methods.stakeMerge().accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             destinationStake,
             sourceStake
         }).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async splitStakeTx(glamState, existingStake, lamports, txOptions = {}) {
+    async splitStakeTx(existingStake, lamports, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const [newStake, createStakeAccountIx] = await this.createStakeAccount(glamSigner);
         const tx = await this.base.program.methods.stakeSplit(lamports).accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             stake: existingStake,
             splitStake: newStake
         }).preInstructions([
@@ -16161,12 +16703,12 @@ class StakingClient {
             newStake
         };
     }
-    async redelegateStakeTx(glamState, existingStake, vote, txOptions = {}) {
+    async redelegateStakeTx(existingStake, vote, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const [newStake, createStakeAccountIx] = await this.createStakeAccount(glamSigner);
         const tx = await this.base.program.methods.stakeRedelegate().accounts({
             glamSigner,
-            glamState,
+            glamState: this.base.statePda,
             vote,
             stake: existingStake,
             newStake,
@@ -16186,51 +16728,49 @@ class StakingClient {
     }
 }
 
-function getPublicKey(input) {
-    return typeof input === "string" ? new web3_js.PublicKey(input) : input;
-}
 class StateClient {
-    async createState(partialStateModel, singleTx = false, txOptions = {}) {
+    async create(partialStateModel, singleTx = false, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         let stateModel = this.enrichStateModel(partialStateModel);
-        // @ts-ignore
-        const glamState = this.base.getStatePda(stateModel);
-        const glamVault = this.base.getVaultPda(glamState);
-        const openfunds = this.base.getOpenfundsPda(glamState);
+        const statePda = getStatePda(stateModel, this.base.program.programId);
+        this.base.statePda = statePda;
+        console.log(`State PDA set to GlamClient: ${statePda}`);
         const mints = stateModel.mints;
         stateModel.mints = [];
         if (mints && mints.length > 1) {
-            throw new Error("Multiple mints not supported");
+            throw new Error("Multiple mints not supported. Only 1 mint is allowed.");
         }
-        // No share class, only need to initialize the state
+        // No mint, only need to initialize the state
         if (mints && mints.length === 0) {
             // @ts-ignore
             const tx = await this.base.program.methods.initializeState(stateModel).accountsPartial({
-                glamState,
+                glamState: statePda,
                 glamSigner,
-                glamVault
+                glamVault: this.base.vaultPda
             }).transaction();
             const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
             const txSig = await this.base.sendAndConfirm(vTx);
             return [
                 txSig,
-                glamState
+                statePda
             ];
         }
-        let extraMetasAccount = mints && mints[0].lockUpPeriodInSeconds && mints[0].lockUpPeriodInSeconds > 0 ? this.base.getExtraMetasPda(glamState) : null;
+        // let extraMetasAccount =
+        //   mints && mints[0].lockUpPeriod && mints[0].lockUpPeriod > 0
+        //     ? this.base.extraMetasPda
+        //     : null;
         // Initialize state and add mint in one transaction
         if (mints && mints.length > 0 && singleTx) {
             const initStateIx = await this.base.program.methods.initializeState(stateModel).accountsPartial({
-                glamState,
+                glamState: statePda,
                 glamSigner,
-                glamVault
+                glamVault: this.base.vaultPda
             }).instruction();
-            const newMint = this.base.getMintPda(glamState, 0);
             const tx = await this.base.program.methods.addMint(mints[0]).accounts({
-                glamState,
+                glamState: statePda,
                 glamSigner,
-                newMint,
-                extraMetasAccount
+                newMint: this.base.mintPda,
+                extraMetasAccount: this.base.extraMetasPda
             }).preInstructions([
                 initStateIx
             ]).transaction();
@@ -16238,53 +16778,73 @@ class StateClient {
             const txSig = await this.base.sendAndConfirm(vTx);
             return [
                 txSig,
-                glamState
+                statePda
             ];
         }
         // Initialize state and add mints in separate transactions
         const tx = await this.base.program.methods.initializeState(stateModel).accountsPartial({
-            glamState,
-            glamVault,
+            glamState: statePda,
+            glamVault: this.base.vaultPda,
             glamSigner,
-            openfundsMetadata: openfunds
+            openfundsMetadata: this.base.openfundsPda
         }).transaction();
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         const txSig = await this.base.sendAndConfirm(vTx);
         await Promise.all((mints || []).map(async (mint, j)=>{
-            const newMint = this.base.getMintPda(glamState, j);
             const tx = await this.base.program.methods.addMint(mint).accounts({
-                glamState,
+                glamState: statePda,
                 glamSigner,
-                newMint,
-                extraMetasAccount
+                newMint: this.base.mintPda,
+                extraMetasAccount: this.base.extraMetasPda
             }).transaction();
             const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
             return await this.base.sendAndConfirm(vTx);
         }));
         return [
             txSig,
-            glamState
+            statePda
         ];
     }
-    async updateState(glamState, updated, txOptions = {}) {
-        if (process.env.NODE_ENV === "development") {
-            console.log(`await glam.state.updateState("${glamState.toString()}", ${JSON.stringify(updated)}, ${JSON.stringify(txOptions)});`);
-        }
-        const tx = await this.updateStateTx(getPublicKey(glamState), updated, txOptions);
+    async update(updated, txOptions = {}) {
+        const tx = await this.updateStateTx(updated, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
+    async updateApplyTimelock(txOptions = {}) {
+        const tx = await this.updateStateApplyTimelockTx(txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async updateStateTx(glamState, updated, txOptions) {
+    async emergencyUpdate(updated, txOptions = {}) {
+        const vTx = await this.emergencyUpdateStateTx(updated, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async updateStateTx(updated, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.program.methods.updateState(new StateIdlModel(updated)).accounts({
-            glamState,
+            glamState: this.base.statePda,
+            glamSigner
+        }).preInstructions(txOptions.preInstructions || []).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    async updateStateApplyTimelockTx(txOptions) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const tx = await this.base.program.methods.updateStateApplyTimelock().accounts({
+            glamState: this.base.statePda,
+            glamSigner
+        }).preInstructions(txOptions.preInstructions || []).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    async emergencyUpdateStateTx(updated, txOptions) {
+        const glamSigner = txOptions.signer || this.base.signer;
+        const tx = await this.base.program.methods.emergencyUpdateState(new StateIdlModel(updated)).accounts({
+            glamState: this.base.statePda,
             glamSigner
         }).preInstructions(txOptions.preInstructions || []).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async closeState(glamState, txOptions = {}) {
+    async close(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.program.methods.closeState().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner
         }).preInstructions(txOptions.preInstructions || []).transaction();
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
@@ -16295,7 +16855,9 @@ class StateClient {
    */ enrichStateModel(partialStateModel) {
         const owner = this.base.getSigner();
         const defaultDate = new Date().toISOString().split("T")[0];
-        partialStateModel.name = this.base.getName(partialStateModel);
+        if (!partialStateModel?.name) {
+            throw new Error("Name must be specified in partial state model");
+        }
         // createdKey = hash state name and get first 8 bytes
         // useful for computing state account PDA in the future
         partialStateModel.created = new CreatedModel({
@@ -16315,13 +16877,13 @@ class StateClient {
             const mint = partialStateModel.mints[0];
             partialStateModel.rawOpenfunds.fundCurrency = partialStateModel.rawOpenfunds?.fundCurrency || mint.rawOpenfunds?.shareClassCurrency || null;
         } else if (partialStateModel.mints?.length && partialStateModel.mints.length > 1) {
-            throw new Error("Fund with more than 1 share class is not supported");
+            throw new Error("Multiple mints are not supported. Only 1 mint is allowed.");
         }
         if (partialStateModel.enabled) {
             partialStateModel.rawOpenfunds.fundLaunchDate = partialStateModel.rawOpenfunds?.fundLaunchDate || defaultDate;
         }
         // fields containing fund id / pda
-        const statePda = this.base.getStatePda(partialStateModel);
+        const statePda = getStatePda(partialStateModel, this.base.program.programId);
         partialStateModel.uri = partialStateModel.uri || `https://gui.glam.systems/products/${statePda}`;
         partialStateModel.metadata = new Metadata({
             ...partialStateModel.metadata,
@@ -16341,10 +16903,10 @@ class StateClient {
             } else {
                 mint.isRawOpenfunds = false;
             }
-            const sharePda = this.base.getMintPda(statePda, i);
-            mint.uri = `https://api.glam.systems/metadata/${sharePda}`;
+            const mintPda = getMintPda(statePda, i, this.base.program.programId);
+            mint.uri = `https://api.glam.systems/metadata/${mintPda}`;
             mint.statePubkey = statePda;
-            mint.imageUri = `https://api.glam.systems/v0/sparkle?key=${sharePda}&format=png`;
+            mint.imageUri = `https://api.glam.systems/v0/sparkle?key=${mintPda}&format=png`;
         });
         // convert partial share class models to full share class models
         partialStateModel.mints = (partialStateModel.mints || []).map((s)=>new MintModel(s));
@@ -16356,31 +16918,30 @@ class StateClient {
    * @param statePda
    * @param delegates Public keys of delegates to be deleted
    * @returns
-   */ async deleteDelegateAcls(statePda, delegates, txOptions = {}) {
-        const updated = new StateModel({
+   */ async deleteDelegateAcls(delegates, txOptions = {}) {
+        return await this.update({
             delegateAcls: delegates.map((pubkey)=>({
                     pubkey,
                     permissions: [],
                     expiresAt: new anchor.BN(0)
                 }))
-        });
-        return await this.updateState(statePda, updated, txOptions);
+        }, txOptions);
     }
-    async upsertDelegateAcls(glamState, delegateAcls, txOptions = {}) {
-        return await this.updateState(glamState, {
+    async upsertDelegateAcls(delegateAcls, txOptions = {}) {
+        return await this.update({
             delegateAcls
         }, txOptions);
     }
-    async closeTokenAccounts(glamState, tokenAccounts, txOptions = {}) {
-        const tx = await this.closeTokenAccountsTx(glamState, tokenAccounts, txOptions);
+    async closeTokenAccounts(tokenAccounts, txOptions = {}) {
+        const tx = await this.closeTokenAccountsTx(tokenAccounts, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /**
    * Close vault's token accounts, all token accounts must use the same token program
-   */ async closeTokenAccountIx(glamState, tokenAccounts, tokenProgram = splToken.TOKEN_PROGRAM_ID, txOptions = {}) {
+   */ async closeTokenAccountIx(tokenAccounts, tokenProgram = splToken.TOKEN_PROGRAM_ID, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         return await this.base.program.methods.tokenCloseAccount().accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             tokenAccount: tokenAccounts[0],
             cpiProgram: tokenProgram
@@ -16390,7 +16951,7 @@ class StateClient {
                 isWritable: true
             }))).instruction();
     }
-    async closeTokenAccountsTx(glamState, accounts, txOptions) {
+    async closeTokenAccountsTx(accounts, txOptions) {
         const accountsInfo = await this.base.provider.connection.getMultipleAccountsInfo(accounts);
         if (accounts.length !== accountsInfo.filter((a)=>!!a).length) {
             throw new Error("Some token accounts do not exist");
@@ -16418,7 +16979,7 @@ class StateClient {
         });
         const ixs = (await Promise.all(Array.from(tokenAccountsByProgram.entries()).map(async ([programId, accounts])=>{
             if (accounts.length === 0) return null;
-            return this.closeTokenAccountIx(glamState, accounts, new web3_js.PublicKey(programId), txOptions);
+            return this.closeTokenAccountIx(accounts, new web3_js.PublicKey(programId), txOptions);
         }))).filter((ix)=>ix !== null);
         if (ixs.length === 0) {
             throw new Error("No token accounts to close");
@@ -16427,80 +16988,78 @@ class StateClient {
         tx.add(...ixs);
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    /* Deposit & Withdraw */ async deposit(glamState, asset, amount, txOptions = {}) {
-        const tx = await this.depositTx(new web3_js.PublicKey(glamState), new web3_js.PublicKey(asset), amount, txOptions);
+    /* Deposit & Withdraw */ async deposit(asset, amount, txOptions = {}) {
+        const tx = await this.depositTx(new web3_js.PublicKey(asset), amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async depositSol(glamState, lamports, wrap = true, txOptions = {}) {
-        const tx = await this.depositSolTx(glamState, lamports, wrap, txOptions);
+    async depositSol(lamports, wrap = true, txOptions = {}) {
+        const tx = await this.depositSolTx(lamports, wrap, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async depositSolTx(glamState, lamports, wrap = true, txOptions = {}) {
+    async depositSolTx(lamports, wrap = true, txOptions = {}) {
         const signer = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
         const _lamports = lamports instanceof anchor.BN ? BigInt(lamports.toString()) : lamports;
         if (!wrap) {
             const tx = new web3_js.Transaction().add(web3_js.SystemProgram.transfer({
                 fromPubkey: signer,
-                toPubkey: vault,
+                toPubkey: this.base.vaultPda,
                 lamports: _lamports
             }));
             return await this.base.intoVersionedTransaction(tx, txOptions);
         }
-        const vaultAta = this.base.getAta(WSOL, vault);
-        const tx = new web3_js.Transaction().add(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, vaultAta, vault, WSOL), web3_js.SystemProgram.transfer({
+        const vaultAta = this.base.getAta(WSOL, this.base.vaultPda);
+        const tx = new web3_js.Transaction().add(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, vaultAta, this.base.vaultPda, WSOL), web3_js.SystemProgram.transfer({
             fromPubkey: signer,
             toPubkey: vaultAta,
             lamports: _lamports
         }), splToken.createSyncNativeInstruction(vaultAta));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async withdraw(glamState, asset, amount, txOptions = {}) {
-        const tx = await this.withdrawTx(glamState, new web3_js.PublicKey(asset), amount, txOptions);
+    async withdraw(asset, amount, txOptions = {}) {
+        const tx = await this.withdrawTx(new web3_js.PublicKey(asset), amount, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async depositTx(statePda, asset, amount, txOptions) {
+    async depositTx(asset, amount, txOptions) {
         const signer = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(statePda);
-        const { mint, tokenProgram } = await this.base.fetchMintWithOwner(asset);
+        const { mint, tokenProgram } = await this.base.fetchMintAndTokenProgram(asset);
         const signerAta = this.base.getAta(asset, signer, tokenProgram);
-        const vaultAta = this.base.getVaultAta(statePda, asset, tokenProgram);
-        const tx = new web3_js.Transaction().add(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, vaultAta, vault, asset, tokenProgram), splToken.createTransferCheckedInstruction(signerAta, asset, vaultAta, signer, new anchor.BN(amount).toNumber(), mint.decimals, [], tokenProgram));
+        const vaultAta = this.base.getAta(asset, this.base.vaultPda, tokenProgram);
+        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(glamState, asset, amount, txOptions) {
+    async withdrawIxs(asset, amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { tokenProgram } = await this.base.fetchMintWithOwner(asset);
+        const { tokenProgram } = await this.base.fetchMintAndTokenProgram(asset);
         const signerAta = this.base.getAta(asset, glamSigner, tokenProgram);
         return [
             splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, signerAta, glamSigner, asset, tokenProgram),
             await this.base.program.methods.withdraw(new anchor.BN(amount)).accounts({
-                glamState,
+                glamState: this.base.statePda,
                 glamSigner,
                 asset,
                 tokenProgram
             }).instruction()
         ];
     }
-    async withdrawTx(glamState, asset, amount, txOptions) {
+    async withdrawTx(asset, amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const { tokenProgram } = await this.base.fetchMintWithOwner(asset);
+        const { tokenProgram } = await this.base.fetchMintAndTokenProgram(asset);
         const signerAta = this.base.getAta(asset, glamSigner, tokenProgram);
         const preInstructions = [
             splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, signerAta, glamSigner, asset, tokenProgram)
         ];
         const postInstructions = [];
         if (asset.equals(WSOL)) {
-            const wrapSolIxs = await this.base.maybeWrapSol(glamState, amount, glamSigner);
+            const wrapSolIxs = await this.base.maybeWrapSol(amount, glamSigner);
             preInstructions.push(...wrapSolIxs);
             // If we need to wrap SOL, it means the wSOL balance will be drained,
             // and we close the wSOL token account for convenience
-            postInstructions.push(await this.closeTokenAccountIx(glamState, [
-                this.base.getVaultAta(glamState, WSOL)
+            postInstructions.push(await this.closeTokenAccountIx([
+                this.base.getAta(WSOL, this.base.vaultPda)
             ]));
         }
         const tx = await this.base.program.methods.withdraw(new anchor.BN(amount)).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             asset,
             tokenProgram
@@ -16515,9 +17074,12 @@ class StateClient {
 class MintClient {
     // `getTokenAccounts` is a helius only RPC endpoint, we have to hardcode the URL here
     // We cannot use NEXT_PUBLIC_SOLANA_RPC because users may choose to use a non-helius RPC
-    async fetchTokenHolders(state, mintId = 0) {
-        const mint = this.base.getMintPda(state, mintId);
-        const response = await fetch(`https://${this.base.cluster}.helius-rpc.com/?api-key=${process.env.NEXT_PUBLIC_HELIUS_API_KEY}`, {
+    async fetchTokenHolders() {
+        if (!process.env.NEXT_PUBLIC_HELIUS_API_KEY) {
+            return await this.getHolders();
+        }
+        const cluster = this.base.cluster === ClusterNetwork.Mainnet ? "mainnet" : "devnet";
+        const response = await fetch(`https://${cluster}.helius-rpc.com/?api-key=${process.env.NEXT_PUBLIC_HELIUS_API_KEY}`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json"
@@ -16527,7 +17089,7 @@ class MintClient {
                 id: "1",
                 method: "getTokenAccounts",
                 params: {
-                    mint: mint.toBase58(),
+                    mint: this.base.mintPda.toBase58(),
                     options: {
                         showZeroBalance: true
                     }
@@ -16540,7 +17102,7 @@ class MintClient {
         return tokenAccounts.map((ta)=>({
                 owner: new web3_js.PublicKey(ta.owner),
                 pubkey: new web3_js.PublicKey(ta.address),
-                mint,
+                mint: this.base.mintPda,
                 programId: splToken.TOKEN_2022_PROGRAM_ID,
                 decimals: 9,
                 amount: ta.amount,
@@ -16550,16 +17112,9 @@ class MintClient {
     }
     // Much slower than fetchTokenHolders.
     // Use fetchTokenHolders instead when possible.
-    async getHolders(state, mintId = 0) {
-        const mintPda = this.base.getMintPda(state, mintId);
+    async getHolders() {
         const connection = this.base.provider.connection;
-        let mint;
-        try {
-            mint = await splToken.getMint(connection, mintPda, connection.commitment, splToken.TOKEN_2022_PROGRAM_ID);
-        } catch (e) {
-            return [];
-        }
-        // Size of a glam mint with perment delegate extension enabled
+        // dataSize varies due to different sets of extensions enabled
         // const dataSize = 175;
         const accounts = await connection.getProgramAccounts(splToken.TOKEN_2022_PROGRAM_ID, {
             filters: [
@@ -16567,7 +17122,7 @@ class MintClient {
                 {
                     memcmp: {
                         offset: 0,
-                        bytes: mintPda.toBase58()
+                        bytes: this.base.mintPda.toBase58()
                     }
                 }
             ]
@@ -16580,62 +17135,68 @@ class MintClient {
                 pubkey: tokenAccount.address,
                 mint: tokenAccount.mint,
                 programId: splToken.TOKEN_2022_PROGRAM_ID,
-                decimals: mint.decimals,
+                decimals: 9,
                 amount: tokenAccount.amount.toString(),
-                uiAmount: Number(tokenAccount.amount) / 10 ** mint.decimals,
+                uiAmount: Number(tokenAccount.amount) / 10 ** 9,
                 frozen: tokenAccount.isFrozen
             };
         });
     }
-    async update(glamState, mintId, mintModel) {
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        // @ts-ignore
-        const tx = await this.base.program.methods.updateMint(mintId, new MintIdlModel(mintModel)).accounts({
-            glamState,
-            glamMint
+    async update(mintModel, txOptions = {}) {
+        const tx = await this.base.program.methods.updateMint(0, new MintIdlModel(mintModel)).accounts({
+            glamState: this.base.statePda,
+            glamMint: this.base.mintPda
         }).transaction();
-        const vTx = await this.base.intoVersionedTransaction(tx, {});
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
-    async closeMintIx(glamState, mintId = 0) {
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const extraMetasAccount = this.base.getExtraMetasPda(glamState, mintId);
-        // @ts-ignore
-        return await this.base.program.methods.closeMint(mintId).accounts({
-            glamState,
-            glamMint,
-            extraMetasAccount
+    async updateApplyTimelock(txOptions = {}) {
+        const tx = await this.base.program.methods.updateMintApplyTimelock(0).accounts({
+            glamState: this.base.statePda,
+            glamMint: this.base.mintPda
+        }).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async emergencyUpdate(mintModel, txOptions = {}) {
+        const tx = await this.base.program.methods.emergencyUpdateMint(0, new MintIdlModel(mintModel)).accounts({
+            glamState: this.base.statePda,
+            glamMint: this.base.mintPda
+        }).transaction();
+        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async closeMintIx() {
+        return await this.base.program.methods.closeMint(0).accounts({
+            glamState: this.base.statePda,
+            glamMint: this.base.mintPda,
+            extraMetasAccount: this.base.extraMetasPda
         }).instruction();
     }
-    async closeMint(glamState, mintId = 0, txOptions = {}) {
+    async closeMint(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const extraMetasAccount = this.base.getExtraMetasPda(glamState, mintId);
-        // @ts-ignore
-        const tx = await this.base.program.methods.closeMint(mintId).accounts({
-            glamState,
+        const tx = await this.base.program.methods.closeMint(0).accounts({
+            glamState: this.base.statePda,
             glamSigner,
-            glamMint,
-            extraMetasAccount
+            glamMint: this.base.mintPda,
+            extraMetasAccount: this.base.extraMetasPda
         }).transaction();
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
     /**
-   * Create a glam mint token account for a specific user
+   * Create a glam mint token account for the specified user
    *
-   * @param glamState
    * @param owner Owner of the token account
-   * @param mintId ID of the mint (only 0 is supported)
    * @param setFrozen If true, the token account will be frozen
    * @param txOptions
    * @returns Transaction signature
-   */ async createTokenAccount(glamState, owner, mintId = 0, setFrozen = true, txOptions = {}) {
+   */ async createTokenAccount(owner, setFrozen = true, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const ata = this.base.getMintAta(owner, glamMint);
+        const glamMint = this.base.mintPda;
+        const ata = this.base.getMintAta(owner);
         const ixCreateAta = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, ata, owner, glamMint, splToken.TOKEN_2022_PROGRAM_ID);
-        return await this.setTokenAccountsStates(glamState, mintId, [
+        return await this.setTokenAccountsStates([
             ata
         ], setFrozen, {
             preInstructions: [
@@ -16647,19 +17208,16 @@ class MintClient {
     /**
    * Freeze or unfreeze token accounts of a glam mint
    *
-   * @param glamState
-   * @param mintId ID of the mint (only 0 is supported)
    * @param tokenAccounts List of token accounts to freeze or unfreeze
    * @param frozen If true, the token accounts will be frozen; otherwise, they will be unfrozen
    * @param txOptions
    * @returns Transaction signature
-   */ async setTokenAccountsStates(glamState, mintId, tokenAccounts, frozen, txOptions = {}) {
+   */ async setTokenAccountsStates(tokenAccounts, frozen, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const tx = await this.base.program.methods.setTokenAccountsStates(mintId, frozen).accounts({
-            glamState,
+        const tx = await this.base.program.methods.setTokenAccountsStates(0, frozen).accounts({
+            glamState: this.base.statePda,
             glamSigner,
-            glamMint
+            glamMint: this.base.mintPda
         }).remainingAccounts(tokenAccounts.map((account)=>({
                 pubkey: account,
                 isSigner: false,
@@ -16671,25 +17229,21 @@ class MintClient {
     /**
    * Mint tokens to recipient. Token account will be created if it does not exist.
    *
-   * @param glamState
-   * @param mintId ID of the mint (only 0 is supported)
    * @param recipient Recipient public key
    * @param amount Amount of tokens to mint
    * @param forceThaw If true, automatically unfreeze the token account before minting
    * @param txOptions
    * @returns Transaction signature
-   */ async mint(glamState, mintId, recipient, amount, forceThaw = false, txOptions = {}) {
+   */ async mint(recipient, amount, forceThaw = false, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const mintTo = this.base.getMintAta(recipient, glamMint);
+        const mintTo = this.base.getMintAta(recipient);
         const preInstructions = [];
-        preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, mintTo, recipient, glamMint, splToken.TOKEN_2022_PROGRAM_ID));
+        preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, mintTo, recipient, this.base.mintPda, splToken.TOKEN_2022_PROGRAM_ID));
         if (forceThaw) {
-            preInstructions.push(// @ts-ignore
-            await this.base.program.methods.setTokenAccountsStates(mintId, false).accounts({
-                glamState,
+            preInstructions.push(await this.base.program.methods.setTokenAccountsStates(0, false).accounts({
+                glamState: this.base.statePda,
                 glamSigner,
-                glamMint
+                glamMint: this.base.mintPda
             }).remainingAccounts([
                 {
                     pubkey: mintTo,
@@ -16698,12 +17252,12 @@ class MintClient {
                 }
             ]).instruction());
         }
-        let policyAccount = await this.base.isLockupEnabled(glamState) ? this.base.getAccountPolicyPda(glamState, recipient) : null;
+        let policyAccount = await this.base.isLockupEnabled() ? getAccountPolicyPda(mintTo) : null;
         // @ts-ignore
         const tx = await this.base.program.methods.mintTokens(0, amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
-            glamMint,
+            glamMint: this.base.mintPda,
             recipient,
             policyAccount
         }).preInstructions(preInstructions).transaction();
@@ -16713,24 +17267,20 @@ class MintClient {
     /**
    * Burn tokens from a token account
    *
-   * @param glamState
-   * @param mintId ID of the mint (only 0 is supported)
    * @param amount Amount of tokens to burn
    * @param from Owner of the token account
    * @param forceThaw If true, automatically unfree the token account before burning
    * @param txOptions
    * @returns Transaction signature
-   */ async burn(glamState, mintId, amount, from, forceThaw = false, txOptions = {}) {
+   */ async burn(amount, from, forceThaw = false, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const ata = this.base.getMintAta(from, glamMint);
+        const ata = this.base.getMintAta(from);
         const preInstructions = [];
         if (forceThaw) {
-            preInstructions.push(// @ts-ignore
-            await this.base.program.methods.setTokenAccountsStates(mintId, false).accounts({
-                glamState,
+            preInstructions.push(await this.base.program.methods.setTokenAccountsStates(0, false).accounts({
+                glamState: this.base.statePda,
                 glamSigner,
-                glamMint
+                glamMint: this.base.mintPda
             }).remainingAccounts([
                 {
                     pubkey: ata,
@@ -16739,10 +17289,10 @@ class MintClient {
                 }
             ]).instruction());
         }
-        const tx = await this.base.program.methods.burnTokens(mintId, amount).accounts({
-            glamState,
+        const tx = await this.base.program.methods.burnTokens(0, amount).accounts({
+            glamState: this.base.statePda,
             glamSigner,
-            glamMint,
+            glamMint: this.base.mintPda,
             from
         }).preInstructions(preInstructions).transaction();
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
@@ -16751,27 +17301,23 @@ class MintClient {
     /**
    * Transfer tokens from one token account to another
    *
-   * @param glamState
-   * @param mintId ID of the mint (only 0 is supported)
    * @param amount Amount of tokens to transfer
    * @param from Owner of the sender token account
    * @param to Owner of the recipient token account
    * @param forceThaw If true, automatically unfree the token accounts before transfer
    * @param txOptions
    * @returns
-   */ async forceTransfer(glamState, mintId, amount, from, to, forceThaw = false, txOptions = {}) {
+   */ async forceTransfer(amount, from, to, forceThaw = false, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const fromAta = this.base.getMintAta(from, glamMint);
-        const toAta = this.base.getMintAta(to, glamMint);
+        const fromAta = this.base.getMintAta(from);
+        const toAta = this.base.getMintAta(to);
         const preInstructions = [];
-        preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(this.base.getSigner(), toAta, to, glamMint, splToken.TOKEN_2022_PROGRAM_ID));
+        preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(this.base.getSigner(), toAta, to, this.base.mintPda, splToken.TOKEN_2022_PROGRAM_ID));
         if (forceThaw) {
-            preInstructions.push(// @ts-ignore
-            await this.base.program.methods.setTokenAccountsStates(mintId, false).accounts({
-                glamState,
+            preInstructions.push(await this.base.program.methods.setTokenAccountsStates(0, false).accounts({
+                glamState: this.base.statePda,
                 glamSigner,
-                glamMint
+                glamMint: this.base.mintPda
             }).remainingAccounts([
                 // fromAta is already unfrozen, still add it to test the ix is idempotent
                 {
@@ -16788,10 +17334,10 @@ class MintClient {
         }
         const remainingAccounts = [];
         let toPolicyAccount = null;
-        if (await this.base.isLockupEnabled(glamState)) {
-            const extraMetasAccount = this.base.getExtraMetasPda(glamState, mintId);
-            const fromPolicy = this.base.getAccountPolicyPda(glamState, from);
-            const toPolicy = this.base.getAccountPolicyPda(glamState, to);
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const fromPolicy = getAccountPolicyPda(this.base.getMintAta(from));
+            const toPolicy = getAccountPolicyPda(this.base.getMintAta(to));
             toPolicyAccount = toPolicy;
             remainingAccounts.push(...[
                 extraMetasAccount,
@@ -16800,11 +17346,10 @@ class MintClient {
                 TRANSFER_HOOK_PROGRAM
             ]);
         }
-        // @ts-ignore
-        const tx = await this.base.program.methods.forceTransferTokens(mintId, amount).accounts({
-            glamState,
+        const tx = await this.base.program.methods.forceTransferTokens(0, amount).accounts({
+            glamState: this.base.statePda,
             glamSigner,
-            glamMint,
+            glamMint: this.base.mintPda,
             from,
             to,
             toPolicyAccount
@@ -16826,7 +17371,6 @@ const DEFAULT_OBLIGATION_ARGS = {
     tag: 0,
     id: 0
 };
-const SCOPE_PRICES = new web3_js.PublicKey("3NJYftD5sjVfxSnUdZ1wVML8f3aC6mp1CXCL6L7TnU8C");
 function refreshObligation(accounts, programId = KAMINO_LENDING_PROGRAM) {
     const keys = [
         {
@@ -17001,65 +17545,60 @@ class KaminoLendingClient {
     /**
    * Initializes Kamino user metadata
    *
-   * @param statePda
    * @param market Lending market
    * @param referrer Referrer user metadata
    * @param txOptions
    * @returns
-   */ async initUserMetadata(statePda, referrer, txOptions = {}) {
-        const tx = await this.initUserMetadataTx(new web3_js.PublicKey(statePda), referrer ? new web3_js.PublicKey(referrer) : null, txOptions);
+   */ async initUserMetadata(txOptions = {}) {
+        const tx = await this.initUserMetadataTx(txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /**
    * Deposits asset to the lending market.
    *
-   * @param statePda
    * @param market Lending market
    * @param asset Asset mint
    * @param amount Amount to deposit
    * @param txOptions
    * @returns
-   */ async deposit(statePda, market, asset, amount, txOptions = {}) {
-        const tx = await this.depositTx(new web3_js.PublicKey(statePda), new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
+   */ async deposit(market, asset, amount, txOptions = {}) {
+        const tx = await this.depositTx(new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /**
    * Withdraws asset from the lending market.
    *
-   * @param statePda
    * @param market Lending market
    * @param asset Asset mint
    * @param amount Amount to deposit
    * @param txOptions
    * @returns
-   */ async withdraw(statePda, market, asset, amount, txOptions = {}) {
-        const tx = await this.withdrawTx(new web3_js.PublicKey(statePda), new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
+   */ async withdraw(market, asset, amount, txOptions = {}) {
+        const tx = await this.withdrawTx(new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /**
    * Borrows asset from the lending market.
    *
-   * @param statePda GLAM state
    * @param market Lending market
    * @param asset Asset mint
    * @param amount Amount to borrow
    * @param txOptions
    * @returns
-   */ async borrow(statePda, market, asset, amount, txOptions = {}) {
-        const tx = await this.borrowTx(new web3_js.PublicKey(statePda), new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
+   */ async borrow(market, asset, amount, txOptions = {}) {
+        const tx = await this.borrowTx(new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     /**
    * Repays asset to the lending market.
    *
-   * @param statePda
    * @param market
    * @param asset
    * @param amount
    * @param txOptions
    * @returns
-   */ async repay(statePda, market, asset, amount, txOptions = {}) {
-        const tx = await this.repayTx(new web3_js.PublicKey(statePda), new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
+   */ async repay(market, asset, amount, txOptions = {}) {
+        const tx = await this.repayTx(new web3_js.PublicKey(market), new web3_js.PublicKey(asset), new anchor.BN(amount), txOptions);
         return await this.base.sendAndConfirm(tx);
     }
     getUserMetadataPda(owner) {
@@ -17093,17 +17632,17 @@ class KaminoLendingClient {
         ], KAMINO_FARM_PROGRAM);
         return obligationFarm;
     }
-    async initUserMetadataTx(glamState, referrer, txOptions = {}) {
+    async initUserMetadataTx(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        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,
+            glamState: this.base.statePda,
             glamSigner,
             userMetadata,
-            referrerUserMetadata: referrer
+            referrerUserMetadata: null
         }).transaction();
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
@@ -17115,7 +17654,7 @@ class KaminoLendingClient {
                 pythOracle: KAMINO_LENDING_PROGRAM,
                 switchboardPriceOracle: KAMINO_LENDING_PROGRAM,
                 switchboardTwapOracle: KAMINO_LENDING_PROGRAM,
-                scopePrices: SCOPE_PRICES
+                scopePrices: KAMINO_SCOPE_PRICES
             }));
     }
     refreshObligationFarmsForReserveIxs(obligation, lendingMarket, parsedReserves) {
@@ -17321,9 +17860,9 @@ class KaminoLendingClient {
         this.reserves.set(account.pubkey, parsedReserve);
         return parsedReserve;
     }
-    async depositTx(glamState, market, asset, amount, txOptions) {
+    async depositTx(market, asset, amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const userMetadata = this.getUserMetadataPda(vault);
         const preInstructions = [];
         const postInstructions = [];
@@ -17333,7 +17872,7 @@ class KaminoLendingClient {
         const obligationAccount = await this.base.provider.connection.getAccountInfo(obligation);
         if (!obligationAccount) {
             preInstructions.push(await this.base.program.methods.kaminoLendingInitObligation(DEFAULT_OBLIGATION_ARGS).accounts({
-                glamState,
+                glamState: this.base.statePda,
                 glamSigner,
                 obligation,
                 lendingMarket: market,
@@ -17350,7 +17889,7 @@ class KaminoLendingClient {
             if (!obligationFarmAccount) {
                 preInstructions.push(await this.base.program.methods.kaminoLendingInitObligationFarmsForReserve(0) // TODO: What does mode do?
                 .accounts({
-                    glamState,
+                    glamState: this.base.statePda,
                     glamSigner,
                     obligation,
                     lendingMarketAuthority: this.getMarketAuthority(market),
@@ -17386,14 +17925,14 @@ class KaminoLendingClient {
             postInstructions.push(...ixs); // farms must be refreshed after deposit
         }
         // If deposit asset is WSOL, wrap SOL first in case vault doesn't have enough wSOL
-        const userSourceLiquidity = this.base.getVaultAta(glamState, asset);
+        const userSourceLiquidity = this.base.getVaultAta(asset);
         if (asset.equals(WSOL)) {
-            const wrapSolIxs = await this.base.maybeWrapSol(glamState, amount);
+            const wrapSolIxs = await this.base.maybeWrapSol(amount);
             preInstructions.unshift(...wrapSolIxs);
             // Close wSOL ata automatically after deposit
             if (wrapSolIxs.length > 0) {
                 const closeIx = await this.base.program.methods.tokenCloseAccount().accounts({
-                    glamState,
+                    glamState: this.base.statePda,
                     glamSigner,
                     tokenAccount: userSourceLiquidity,
                     cpiProgram: splToken.TOKEN_PROGRAM_ID
@@ -17403,7 +17942,7 @@ class KaminoLendingClient {
         }
         // @ts-ignore
         const tx = await this.base.program.methods.kaminoLendingDepositReserveLiquidityAndObligationCollateralV2(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             obligation,
             lendingMarket: market,
@@ -17431,9 +17970,9 @@ class KaminoLendingClient {
         });
         return vTx;
     }
-    async withdrawTx(glamState, market, asset, amount, txOptions) {
+    async withdrawTx(market, asset, amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const preInstructions = [];
         const postInstructions = [];
         const withdrawReserve = await this.findAndParseReserve(market, asset);
@@ -17446,7 +17985,7 @@ class KaminoLendingClient {
             if (!obligationFarmAccount) {
                 preInstructions.push(await this.base.program.methods.kaminoLendingInitObligationFarmsForReserve(0) // TODO: What does mode do?
                 .accounts({
-                    glamState,
+                    glamState: this.base.statePda,
                     glamSigner,
                     obligation,
                     lendingMarketAuthority: this.getMarketAuthority(market),
@@ -17482,11 +18021,11 @@ class KaminoLendingClient {
             postInstructions.push(...ixs); // farms must be refreshed after withdraw
         }
         // Create asset ATA in case it doesn't exist. Add it to the beginning of preInstructions
-        const userDestinationLiquidity = this.base.getVaultAta(glamState, asset);
+        const userDestinationLiquidity = this.base.getVaultAta(asset);
         const createAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userDestinationLiquidity, vault, asset);
         preInstructions.unshift(createAtaIx);
         const withdrawIx = await this.base.program.methods.kaminoLendingWithdrawObligationCollateralAndRedeemReserveCollateralV2(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             obligation,
             lendingMarket: market,
@@ -17496,7 +18035,7 @@ class KaminoLendingClient {
             reserveSourceCollateral: withdrawReserve.collateralSupplyVault,
             reserveCollateralMint: withdrawReserve.collateralMint,
             reserveLiquiditySupply: withdrawReserve.liquiditySupplyVault,
-            userDestinationLiquidity: this.base.getVaultAta(glamState, asset),
+            userDestinationLiquidity,
             placeholderUserDestinationCollateral: null,
             collateralTokenProgram: splToken.TOKEN_PROGRAM_ID,
             liquidityTokenProgram: splToken.TOKEN_PROGRAM_ID,
@@ -17522,9 +18061,9 @@ class KaminoLendingClient {
         });
         return vTx;
     }
-    async borrowTx(glamState, market, asset, amount, txOptions) {
+    async borrowTx(market, asset, amount, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const preInstructions = [];
         const borrowReserve = await this.findAndParseReserve(market, asset);
         const obligation = this.getObligationPda(vault, market, DEFAULT_OBLIGATION_ARGS);
@@ -17536,7 +18075,7 @@ class KaminoLendingClient {
             if (!obligationFarmAccount) {
                 preInstructions.push(await this.base.program.methods.kaminoLendingInitObligationFarmsForReserve(0) // TODO: What does mode do?
                 .accounts({
-                    glamState,
+                    glamState: this.base.statePda,
                     glamSigner,
                     obligation,
                     lendingMarketAuthority: this.getMarketAuthority(market),
@@ -17574,11 +18113,11 @@ class KaminoLendingClient {
       postInstructions.push(...ixs); // farms must be refreshed after deposit
     }
     */ // Create asset ATA in case it doesn't exist. Add it to the beginning of preInstructions
-        const userDestinationLiquidity = this.base.getVaultAta(glamState, asset);
+        const userDestinationLiquidity = this.base.getVaultAta(asset);
         const createAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, userDestinationLiquidity, vault, asset);
         preInstructions.unshift(createAtaIx);
         const borrowIx = await this.base.program.methods.kaminoLendingBorrowObligationLiquidityV2(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             obligation,
             lendingMarket: market,
@@ -17587,7 +18126,7 @@ class KaminoLendingClient {
             borrowReserveLiquidityMint: asset,
             reserveSourceLiquidity: borrowReserve.liquiditySupplyVault,
             borrowReserveLiquidityFeeReceiver: borrowReserve.feeVault,
-            userDestinationLiquidity: this.base.getVaultAta(glamState, asset),
+            userDestinationLiquidity,
             referrerTokenState: null,
             instructionSysvarAccount: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
             tokenProgram: splToken.TOKEN_PROGRAM_ID,
@@ -17610,9 +18149,9 @@ class KaminoLendingClient {
         });
         return vTx;
     }
-    async repayTx(glamState, market, asset, amount, txOptions = {}) {
+    async repayTx(market, asset, amount, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const preInstructions = [];
         const repayReserve = await this.findAndParseReserve(market, asset);
         const obligation = this.getObligationPda(vault, market, DEFAULT_OBLIGATION_ARGS);
@@ -17624,7 +18163,7 @@ class KaminoLendingClient {
             if (!obligationFarmAccount) {
                 preInstructions.push(await this.base.program.methods.kaminoLendingInitObligationFarmsForReserve(0) // TODO: What does mode do?
                 .accounts({
-                    glamState,
+                    glamState: this.base.statePda,
                     glamSigner,
                     obligation,
                     lendingMarketAuthority: this.getMarketAuthority(market),
@@ -17653,7 +18192,7 @@ class KaminoLendingClient {
             reserves: reservesInUse
         }));
         const repayIx = await this.base.program.methods.kaminoLendingRepayObligationLiquidityV2(amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamSigner,
             obligation,
             lendingMarket: market,
@@ -17661,7 +18200,7 @@ class KaminoLendingClient {
             repayReserve: repayReserve.address,
             reserveLiquidityMint: asset,
             reserveDestinationLiquidity: repayReserve.liquiditySupplyVault,
-            userSourceLiquidity: this.base.getVaultAta(glamState, asset),
+            userSourceLiquidity: this.base.getVaultAta(asset),
             instructionSysvarAccount: web3_js.SYSVAR_INSTRUCTIONS_PUBKEY,
             tokenProgram: splToken.TOKEN_PROGRAM_ID,
             obligationFarmUserState: obligationFarm,
@@ -17769,13 +18308,13 @@ class KaminoFarmClient {
         }
         return map;
     }
-    async harvest(statePda, txOptions = {}) {
-        const tx = await this.harvestTx(new web3_js.PublicKey(statePda), txOptions);
+    async harvest(txOptions = {}) {
+        const tx = await this.harvestTx(txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async harvestTx(glamState, txOptions = {}) {
+    async harvestTx(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const farmStates = await this.findAndParseFarmStates(vault);
         const parsedFarms = await this.fetchAndParseFarms(farmStates.map((f)=>f.farmState));
         const tx = new web3_js.Transaction();
@@ -17783,10 +18322,10 @@ class KaminoFarmClient {
             const { globalConfig, rewards } = parsedFarms.get(farmState.toBase58());
             for (const { index, mint, tokenProgram, rewardsVault } of rewards){
                 console.log("Reward token:", mint.toBase58());
-                const vaultAta = this.base.getVaultAta(glamState, mint, tokenProgram);
+                const vaultAta = this.base.getVaultAta(mint, tokenProgram);
                 const createAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultAta, vault, mint, tokenProgram);
                 const harvestIx = await this.base.program.methods.kaminoFarmHarvestReward(new anchor.BN(index)).accounts({
-                    glamState,
+                    glamState: this.base.statePda,
                     glamSigner,
                     userState: userFarmState,
                     farmState,
@@ -17840,8 +18379,7 @@ class MeteoraDlmmClient {
         }
         return dlmmPool;
     }
-    async initializePosition(statePda, pool, txOptions = {}) {
-        const glamState = new web3_js.PublicKey(statePda);
+    async initializePosition(pool, txOptions = {}) {
         const dlmmPool = await this.getDlmmPool(pool);
         const activeBin = await dlmmPool.getActiveBin();
         const minBinId = activeBin.binId - DEFAULT_RANGE_INTERVAL;
@@ -17849,7 +18387,7 @@ class MeteoraDlmmClient {
         const position = web3_js.Keypair.generate();
         // @ts-ignore
         const tx = await this.base.program.methods.meteoraDlmmInitializePosition(minBinId, maxBinId - minBinId + 1).accounts({
-            glamState,
+            glamState: this.base.statePda,
             lbPair: new web3_js.PublicKey(pool),
             position: position.publicKey,
             eventAuthority: EVENT_AUTHORITY,
@@ -17860,17 +18398,16 @@ class MeteoraDlmmClient {
             position
         ]);
     }
-    async initializePositionPda(statePda, pool, txOptions = {}) {
-        const glamState = new web3_js.PublicKey(statePda);
+    async initializePositionPda(pool, txOptions = {}) {
         const dlmmPool = await this.getDlmmPool(pool);
         const activeBin = await dlmmPool.getActiveBin();
         const minBinId = activeBin.binId - DEFAULT_RANGE_INTERVAL;
         const maxBinId = activeBin.binId + DEFAULT_RANGE_INTERVAL;
         const width = maxBinId - minBinId + 1;
-        const position = this.getPositionPda(new web3_js.PublicKey(pool), this.base.getVaultPda(glamState), minBinId, width);
+        const position = this.getPositionPda(new web3_js.PublicKey(pool), this.base.vaultPda, minBinId, width);
         // @ts-ignore
         const tx = await this.base.program.methods.meteoraDlmmInitializePositionPda(minBinId, width).accounts({
-            glamState,
+            glamState: this.base.statePda,
             lbPair: new web3_js.PublicKey(pool),
             position,
             eventAuthority: EVENT_AUTHORITY,
@@ -17879,13 +18416,12 @@ class MeteoraDlmmClient {
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
-    async addLiquidityByStrategy(statePda, position, amountX, amountY, strategyType, txOptions = {}) {
+    async addLiquidityByStrategy(position, amountX, amountY, strategyType, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const { lbPair, lowerBinId, upperBinId, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, new web3_js.PublicKey(position));
         const dlmmPool = await this.getDlmmPool(lbPair);
         const activeBinId = (await dlmmPool.getActiveBin()).binId;
-        const glamState = new web3_js.PublicKey(statePda);
-        const glamVault = this.base.getVaultPda(glamState);
+        const glamVault = this.base.vaultPda;
         const vaultTokenXAta = this.base.getAta(dlmmPool.tokenX.publicKey, glamVault);
         const vaultTokenYAta = this.base.getAta(dlmmPool.tokenY.publicKey, glamVault);
         const liquidityParameter = {
@@ -17916,7 +18452,7 @@ class MeteoraDlmmClient {
         const tx = await this.base.program.methods.meteoraDlmmAddLiquidityByStrategy2(liquidityParameter, {
             slices: []
         }).accounts({
-            glamState,
+            glamState: this.base.statePda,
             position: new web3_js.PublicKey(position),
             lbPair,
             binArrayBitmapExtension: dlmmPool.binArrayBitmapExtension ? dlmmPool.binArrayBitmapExtension.publicKey : METEORA_DLMM_PROGRAM,
@@ -17934,12 +18470,11 @@ class MeteoraDlmmClient {
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return this.base.sendAndConfirm(vTx);
     }
-    async removeLiquidityByRange(statePda, position, bpsToRemove, txOptions = {}) {
+    async removeLiquidityByRange(position, bpsToRemove, txOptions = {}) {
         const { lbPair, lowerBinId, upperBinId, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, new web3_js.PublicKey(position));
         const dlmmPool = await this.getDlmmPool(lbPair);
-        const glamState = new web3_js.PublicKey(statePda);
-        const vaultTokenXAta = this.base.getVaultAta(glamState, dlmmPool.tokenX.publicKey);
-        const vaultTokenYAta = this.base.getVaultAta(glamState, dlmmPool.tokenY.publicKey);
+        const vaultTokenXAta = this.base.getVaultAta(dlmmPool.tokenX.publicKey);
+        const vaultTokenYAta = this.base.getVaultAta(dlmmPool.tokenY.publicKey);
         const remainingAccounts = [
             binArrayLower,
             binArrayUpper
@@ -17952,7 +18487,7 @@ class MeteoraDlmmClient {
         const tx = await this.base.program.methods.meteoraDlmmRemoveLiquidityByRange2(lowerBinId, upperBinId, bpsToRemove, {
             slices: []
         }).accounts({
-            glamState,
+            glamState: this.base.statePda,
             position: new web3_js.PublicKey(position),
             lbPair,
             binArrayBitmapExtension: dlmmPool.binArrayBitmapExtension ? dlmmPool.binArrayBitmapExtension.publicKey : METEORA_DLMM_PROGRAM,
@@ -17971,12 +18506,11 @@ class MeteoraDlmmClient {
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return this.base.sendAndConfirm(vTx);
     }
-    async claimFee(statePda, position, txOptions = {}) {
+    async claimFee(position, txOptions = {}) {
         const { lbPair, lowerBinId, upperBinId, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, new web3_js.PublicKey(position));
         const dlmmPool = await this.getDlmmPool(lbPair);
-        const glamState = new web3_js.PublicKey(statePda);
-        const vaultTokenXAta = this.base.getVaultAta(glamState, dlmmPool.tokenX.publicKey);
-        const vaultTokenYAta = this.base.getVaultAta(glamState, dlmmPool.tokenY.publicKey);
+        const vaultTokenXAta = this.base.getVaultAta(dlmmPool.tokenX.publicKey);
+        const vaultTokenYAta = this.base.getVaultAta(dlmmPool.tokenY.publicKey);
         const remainingAccounts = [
             binArrayLower,
             binArrayUpper
@@ -17989,7 +18523,7 @@ class MeteoraDlmmClient {
         const tx = await this.base.program.methods.meteoraDlmmClaimFee2(lowerBinId, upperBinId, {
             slices: []
         }).accounts({
-            glamState,
+            glamState: this.base.statePda,
             position: new web3_js.PublicKey(position),
             lbPair,
             reserveX: dlmmPool.tokenX.reserve,
@@ -18007,13 +18541,12 @@ class MeteoraDlmmClient {
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
-    async closePosition(statePda, position, txOptions = {}) {
+    async closePosition(position, txOptions = {}) {
         const { lbPair, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, new web3_js.PublicKey(position));
-        const glamState = new web3_js.PublicKey(statePda);
         console.log(`close position: ${position}, binArrayLower: ${binArrayLower}, binArrayUpper: ${binArrayUpper}`);
         // @ts-ignore
         const tx = await this.base.program.methods.meteoraDlmmClosePosition().accounts({
-            glamState,
+            glamState: this.base.statePda,
             position: new web3_js.PublicKey(position),
             lbPair,
             binArrayLower,
@@ -18058,42 +18591,42 @@ class MeteoraDlmmClient {
 }
 
 class InvestorClient {
-    async subscribe(statePda, asset, amount, mintId = 0, queued = false, txOptions = {}) {
-        const tx = await (queued ? this.queuedSubscribeTx(statePda, asset, amount, mintId, txOptions) : this.subscribeTx(statePda, asset, amount, mintId, txOptions));
+    async subscribe(asset, amount, mintId = 0, queued = false, txOptions = {}) {
+        const tx = await (queued ? this.queuedSubscribeTx(asset, amount, mintId, txOptions) : this.subscribeTx(asset, amount, mintId, txOptions));
         return await this.base.sendAndConfirm(tx);
     }
-    async queuedRedeem(statePda, asset, amount, mintId = 0, txOptions = {}) {
-        const tx = await this.queuedRedeemTx(statePda, asset, amount, mintId, txOptions);
+    async queuedRedeem(asset, amount, mintId = 0, txOptions = {}) {
+        const tx = await this.queuedRedeemTx(asset, amount, mintId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async fulfill(statePda, asset, mintId = 0, txOptions = {}) {
-        const tx = await this.fulfillTx(statePda, asset, mintId, txOptions);
+    async fulfill(asset, mintId = 0, txOptions = {}) {
+        const tx = await this.fulfillTx(asset, mintId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async claim(statePda, asset, mintId = 0, txOptions = {}) {
+    async claim(asset, mintId = 0, txOptions = {}) {
         // Claim WSOL from redeemed shares
         if (asset.equals(WSOL)) {
-            const tx = await this.claimAssetTx(statePda, asset, mintId, txOptions);
+            const tx = await this.claimAssetTx(asset, mintId, txOptions);
             return await this.base.sendAndConfirm(tx);
         }
         // Claim shares after subscription is fulfilled
-        const glamMint = this.base.getMintPda(statePda, mintId);
+        const glamMint = this.base.mintPda;
         if (glamMint.equals(asset)) {
-            const tx = await this.claimShareTx(statePda, asset, mintId, txOptions);
+            const tx = await this.claimShareTx(asset, mintId, txOptions);
             return await this.base.sendAndConfirm(tx);
         }
         throw new Error(`Invalid asset to claim: ${asset.toBase58()}`);
     }
-    async subscribeTx(glamState, asset, amount, mintId = 0, txOptions = {}) {
+    async subscribeTx(asset, amount, mintId = 0, txOptions = {}) {
         if (mintId !== 0 || !asset.equals(WSOL)) {
             throw new Error("Only WSOL is supported & mintId must be 0");
         }
         const signer = txOptions.signer || this.base.getSigner();
         // glam mint token to receive
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const mintTo = this.base.getMintAta(signer, glamMint);
+        const glamMint = this.base.mintPda;
+        const mintTo = this.base.getMintAta(signer);
         // asset token to transfer to vault
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const vaultInput = this.base.getAta(asset, vault);
         const signerInput = this.base.getAta(asset, signer);
         const wrapSolIxs = asset.equals(WSOL) ? [
@@ -18116,13 +18649,13 @@ class InvestorClient {
         ] : [];
         // Check if lockup is enabled on the fund, if so, add signerPolicy
         let signerPolicy = null;
-        if (await this.base.isLockupEnabled(glamState)) {
-            signerPolicy = this.base.getAccountPolicyPda(glamState, signer);
+        if (await this.base.isLockupEnabled()) {
+            signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
             console.log(`signerPolicy: ${signerPolicy} for signer ${signer} and token account ${mintTo}`);
         }
         // @ts-ignore
         const tx = await this.base.program.methods.subscribe(0, amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamMint,
             signer,
             depositAsset: asset,
@@ -18130,13 +18663,13 @@ class InvestorClient {
         }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async queuedSubscribeTx(glamState, asset, amount, mintId = 0, txOptions = {}) {
+    async queuedSubscribeTx(asset, amount, mintId = 0, txOptions = {}) {
         if (mintId !== 0 || !asset.equals(WSOL)) {
             throw new Error("Only WSOL is supported & mintId must be 0");
         }
         const signer = txOptions.signer || this.base.getSigner();
         // asset token to transfer to escrow
-        const escrow = this.base.getEscrowPda(glamState);
+        const escrow = this.base.escrowPda;
         const escrowAta = this.base.getAta(asset, escrow);
         const signerAta = this.base.getAta(asset, signer);
         const wrapSolIxs = asset.equals(WSOL) ? [
@@ -18158,37 +18691,36 @@ class InvestorClient {
         ] : [];
         // @ts-ignore
         const tx = await this.base.program.methods.queuedSubscribe(0, amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             signer,
             depositAsset: asset
         }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async queuedRedeemTx(glamState, asset, amount, mintId = 0, txOptions = {}) {
+    async queuedRedeemTx(asset, amount, mintId = 0, txOptions = {}) {
         if (mintId !== 0 || !asset.equals(WSOL)) {
             throw new Error("Only WSOL is supported & mintId must be 0");
         }
         const signer = txOptions.signer || this.base.getSigner();
-        const glamMint = this.base.getMintPda(glamState, mintId);
+        const glamMint = this.base.mintPda;
         const preInstructions = [
-            splToken.createAssociatedTokenAccountIdempotentInstruction(signer, this.base.getMintAta(signer, glamMint), signer, glamMint, splToken.TOKEN_2022_PROGRAM_ID)
+            splToken.createAssociatedTokenAccountIdempotentInstruction(signer, this.base.getMintAta(signer), signer, glamMint, splToken.TOKEN_2022_PROGRAM_ID)
         ];
         const remainingAccounts = [];
-        if (await this.base.isLockupEnabled(glamState)) {
-            const extraMetasAccount = this.base.getExtraMetasPda(glamState, mintId);
-            const signerPolicy = this.base.getAccountPolicyPda(glamState, signer);
-            const escrow = this.base.getEscrowPda(glamState);
-            const escrowPolicy = this.base.getAccountPolicyPda(glamState, escrow);
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
+            const escrow = this.base.escrowPda;
+            const escrowPolicy = getAccountPolicyPda(this.base.getMintAta(escrow));
             remainingAccounts.push(...[
                 extraMetasAccount,
-                glamState,
                 signerPolicy,
                 escrowPolicy,
                 TRANSFER_HOOK_PROGRAM
             ]);
         }
         const tx = await this.base.program.methods.queuedRedeem(0, amount).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamMint,
             signer
         }).preInstructions(preInstructions).remainingAccounts(remainingAccounts.map((pubkey)=>({
@@ -18198,16 +18730,16 @@ class InvestorClient {
             }))).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async fulfillTx(glamState, asset, mintId = 0, txOptions = {}) {
+    async fulfillTx(asset, mintId = 0, txOptions = {}) {
         if (mintId !== 0 || !asset.equals(WSOL)) {
             throw new Error("Only WSOL is supported & mintId must be 0");
         }
         const signer = txOptions.signer || this.base.getSigner();
-        const vault = this.base.getVaultPda(glamState);
+        const vault = this.base.vaultPda;
         const vaultAssetAta = this.base.getAta(asset, vault);
-        const glamMint = this.base.getMintPda(glamState, mintId);
-        const escrow = this.base.getEscrowPda(glamState);
-        const escrowMintAta = this.base.getMintAta(escrow, glamMint);
+        const glamMint = this.base.mintPda;
+        const escrow = this.base.escrowPda;
+        const escrowMintAta = this.base.getMintAta(escrow);
         const escrowAssetAta = this.base.getAta(asset, escrow);
         let preInstructions = [
             splToken.createAssociatedTokenAccountIdempotentInstruction(signer, escrowMintAta, escrow, glamMint, splToken.TOKEN_2022_PROGRAM_ID),
@@ -18216,22 +18748,22 @@ class InvestorClient {
             ...txOptions.preInstructions || []
         ];
         const tx = await this.base.program.methods.fulfill(mintId).accounts({
-            glamState,
+            glamState: this.base.statePda,
             glamMint,
             signer,
             asset
         }).preInstructions(preInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async claimAssetTx(glamState, asset, mintId = 0, txOptions = {}) {
+    async claimAssetTx(asset, mintId = 0, txOptions = {}) {
         if (mintId !== 0 || !asset.equals(WSOL)) {
             throw new Error("Only WSOL is supported & mintId must be 0");
         }
         const signer = txOptions.signer || this.base.getSigner();
-        this.base.getMintPda(glamState, mintId);
+        this.base.mintPda;
         const signerAta = this.base.getAta(asset, signer);
         const tx = await this.base.program.methods.claim(0).accounts({
-            glamState,
+            glamState: this.base.statePda,
             signer,
             tokenMint: asset,
             tokenProgram: splToken.TOKEN_PROGRAM_ID
@@ -18242,29 +18774,28 @@ class InvestorClient {
         ]).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
-    async claimShareTx(glamState, asset, mintId = 0, txOptions = {}) {
+    async claimShareTx(asset, mintId = 0, txOptions = {}) {
         if (mintId !== 0) {
             throw new Error("mintId must be 0");
         }
         const signer = txOptions.signer || this.base.getSigner();
-        this.base.getMintPda(glamState, mintId);
+        this.base.mintPda;
         const signerAta = this.base.getAta(asset, signer, splToken.TOKEN_2022_PROGRAM_ID);
-        const escrow = this.base.getEscrowPda(glamState);
+        const escrow = this.base.escrowPda;
         const remainingAccounts = [];
-        if (await this.base.isLockupEnabled(glamState)) {
-            const extraMetasAccount = this.base.getExtraMetasPda(glamState, mintId);
-            const signerPolicy = this.base.getAccountPolicyPda(glamState, signer);
-            const escrowPolicy = this.base.getAccountPolicyPda(glamState, escrow);
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
+            const escrowPolicy = getAccountPolicyPda(this.base.getMintAta(escrow));
             remainingAccounts.push(...[
                 extraMetasAccount,
-                glamState,
                 escrowPolicy,
                 signerPolicy,
                 TRANSFER_HOOK_PROGRAM
             ]);
         }
         const tx = await this.base.program.methods.claim(0).accounts({
-            glamState,
+            glamState: this.base.statePda,
             signer,
             tokenMint: asset,
             tokenProgram: splToken.TOKEN_2022_PROGRAM_ID
@@ -18287,9 +18818,10 @@ class PriceClient {
    * !! This is a convenience method that calculates the AUM of the vault based on priced assets.
    * !! It doesn't reflect the actual AUM of the vault.
    * !! If the vault has not been priced or pricing data is outdated, the number is NOT meaningful.
-   */ async getAum(glamState) {
+   */ 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 glamStateAccount = await this.base.fetchStateAccount(glamState);
+        const glamStateAccount = await this.base.fetchStateAccount();
         let pricedAssets = [];
         glamStateAccount.params[0].forEach((param)=>{
             const name = Object.keys(param.name)[0];
@@ -18300,43 +18832,48 @@ class PriceClient {
         });
         return pricedAssets.reduce((sum, p)=>new anchor.BN(p.amount).add(sum), new anchor.BN(0));
     }
-    async priceKaminoIxs(glamState, priceDenom) {
-        const glamVault = this.base.getVaultPda(glamState);
+    async priceKaminoIx(priceDenom) {
+        const glamVault = this.base.vaultPda;
         const obligations = await fetchKaminoObligations(this.base.provider.connection, glamVault);
-        const refreshIxs = [];
-        for (const obligation of obligations){
-            const ixs = await this.klend.getRefreshIxs(obligation, false); // skip farms
-            refreshIxs.push(...ixs);
-        }
+        const parsedObligations = await Promise.all(obligations.map((o)=>this.klend.fetchAndParseObligation(o)));
+        const pubkeySet = new Set([]);
+        parsedObligations.filter((o)=>o.lendingMarket !== null).map((o)=>{
+            pubkeySet.add(o.address.toBase58());
+            pubkeySet.add(o.lendingMarket.toBase58());
+            o.deposits.forEach((d)=>pubkeySet.add(d.reserve.toBase58()));
+            o.borrows.forEach((b)=>pubkeySet.add(b.reserve.toBase58()));
+        });
+        const remainingAccounts = Array.from(pubkeySet).map((k)=>({
+                pubkey: new web3_js.PublicKey(k),
+                isSigner: false,
+                isWritable: true
+            }));
         // @ts-ignore
         const priceIx = await this.base.program.methods.priceKaminoObligations(priceDenom).accounts({
-            glamState,
-            solOracle: SOL_ORACLE
-        }).remainingAccounts(obligations.map((o)=>({
-                pubkey: o,
-                isSigner: false,
-                isWritable: false
-            }))).instruction();
-        return [
-            ...refreshIxs,
-            priceIx
-        ];
+            glamState: this.base.statePda,
+            solOracle: SOL_ORACLE,
+            pythOracle: null,
+            switchboardPriceOracle: null,
+            switchboardTwapOracle: null,
+            scopePrices: KAMINO_SCOPE_PRICES
+        }).remainingAccounts(remainingAccounts).instruction();
+        return priceIx;
     }
-    async priceVaultIxs(glamState, priceDenom) {
-        const vault = this.base.getVaultPda(glamState);
-        const tickets = await fetchMarinadeTicketAccounts(this.base.provider.connection, vault);
+    async priceVaultIxs(priceDenom) {
+        const glamVault = this.base.vaultPda;
+        const tickets = await fetchMarinadeTicketAccounts(this.base.provider.connection, glamVault);
         // @ts-ignore
         const priceTicketsIx = await this.base.program.methods.priceTickets(priceDenom).accounts({
-            glamState,
+            glamState: this.base.statePda,
             solOracle: SOL_ORACLE
         }).remainingAccounts(tickets.map((t)=>({
                 pubkey: t.pubkey,
                 isSigner: false,
                 isWritable: false
             }))).instruction();
-        const stakes = await fetchStakeAccounts(this.base.provider.connection, vault);
+        const stakes = await fetchStakeAccounts(this.base.provider.connection, glamVault);
         const priceStakesIx = await this.base.program.methods.priceStakes(priceDenom).accounts({
-            glamState,
+            glamState: this.base.statePda,
             solOracle: SOL_ORACLE
         }).remainingAccounts(stakes.map((s)=>({
                 pubkey: s,
@@ -18344,27 +18881,50 @@ class PriceClient {
                 isWritable: false
             }))).instruction();
         const priceVaultIx = await this.base.program.methods.priceVault(priceDenom).accounts({
-            glamState,
+            glamState: this.base.statePda,
             solOracle: SOL_ORACLE
-        }).remainingAccounts(await this.remainingAccountsForPricingVaultAssets(glamState)).instruction();
+        }).remainingAccounts(await this.remainingAccountsForPricingVaultAssets()).instruction();
         const priceMeteoraIx = await this.base.program.methods.priceMeteoraPositions(priceDenom).accounts({
-            glamState,
+            glamState: this.base.statePda,
             solOracle: SOL_ORACLE
-        }).remainingAccounts(await this.remainingAccountsForPricingMeteora(glamState)).instruction();
-        const priceKaminoIxs = await this.priceKaminoIxs(glamState, priceDenom);
-        return [
-            priceTicketsIx,
-            priceStakesIx,
-            priceVaultIx,
-            priceMeteoraIx,
-            ...priceKaminoIxs
-        ];
+        }).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();
+            return [
+                priceTicketsIx,
+                priceStakesIx,
+                priceVaultIx,
+                priceMeteoraIx,
+                priceKaminoIx,
+                priceDriftIx
+            ];
+        } catch (error) {
+            // Drift user not found, skip priceDriftIx
+            return [
+                priceTicketsIx,
+                priceStakesIx,
+                priceVaultIx,
+                priceMeteoraIx,
+                priceKaminoIx
+            ];
+        }
     }
-    constructor(base, klend){
+    constructor(base, klend, drift){
         this.base = base;
         this.klend = klend;
-        this.remainingAccountsForPricingMeteora = async (glamState)=>{
-            const glamVault = this.base.getVaultPda(glamState);
+        this.drift = drift;
+        this.remainingAccountsForPricingMeteora = async ()=>{
+            const glamVault = this.base.vaultPda;
             const positions = await fetchMeteoraPositions(this.base.provider.connection, glamVault);
             let chunks = await Promise.all(positions.map(async (pubkey)=>{
                 const { lbPair, binArrayLower, binArrayUpper } = await parseMeteoraPosition(this.base.provider.connection, pubkey);
@@ -18383,10 +18943,10 @@ class PriceClient {
             }));
             return chunks.flat();
         };
-        this.remainingAccountsForPricingVaultAssets = async (glamState)=>{
-            const glamStateAccount = await this.base.fetchStateAccount(glamState);
+        this.remainingAccountsForPricingVaultAssets = async ()=>{
+            const glamStateAccount = await this.base.fetchStateAccount();
             return glamStateAccount.assets.map((asset)=>[
-                    this.base.getVaultAta(glamState, asset),
+                    this.base.getVaultAta(asset),
                     asset,
                     // FIXME: check oracle vs LST state?
                     ASSETS_MAINNET.get(asset.toBase58())?.oracle || new web3_js.PublicKey(0)
@@ -18448,7 +19008,7 @@ class PriceClient {
     }
     get price() {
         if (!this._price) {
-            this._price = new PriceClient(this, this.kaminoLending);
+            this._price = new PriceClient(this, this.kaminoLending, this.drift);
         }
         return this._price;
     }
@@ -18598,6 +19158,7 @@ exports.JupiterVoteClient = JupiterVoteClient;
 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.LPAction = LPAction;
 exports.LiquidationType = LiquidationType;
 exports.MARINADE_PROGRAM_ID = MARINADE_PROGRAM_ID;
@@ -18650,6 +19211,7 @@ exports.StateModel = StateModel;
 exports.SwapDirection = SwapDirection;
 exports.SwapReduceOnly = SwapReduceOnly;
 exports.TRANSFER_HOOK_PROGRAM = TRANSFER_HOOK_PROGRAM;
+exports.TimeUnit = TimeUnit;
 exports.TradeSide = TradeSide;
 exports.USDC = USDC;
 exports.UserStatus = UserStatus;
@@ -18659,19 +19221,27 @@ 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.getAccountPolicyPda = getAccountPolicyPda;
+exports.getEscrowPda = getEscrowPda;
+exports.getExtraMetasPda = getExtraMetasPda;
 exports.getGlamProgram = getGlamProgram;
 exports.getGlamProgramId = getGlamProgramId;
 exports.getLimitOrderParams = getLimitOrderParams;
 exports.getMarketOrderParams = getMarketOrderParams;
+exports.getMintPda = getMintPda;
+exports.getOpenfundsPda = getOpenfundsPda;
 exports.getOrderParams = getOrderParams;
 exports.getPriorityFeeEstimate = getPriorityFeeEstimate;
 exports.getSimulationComputeUnits = getSimulationComputeUnits;
+exports.getStatePda = getStatePda;
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
 exports.getVariant = getVariant;
+exports.getVaultPda = getVaultPda;
 exports.isBrowser = isBrowser;
 exports.isOneOfVariant = isOneOfVariant;
 exports.isVariant = isVariant;