diff --git a/Netezos.Tests/Rpc/TestContextQueries.cs b/Netezos.Tests/Rpc/TestContextQueries.cs
index 3c15e478..8ce514f8 100644
--- a/Netezos.Tests/Rpc/TestContextQueries.cs
+++ b/Netezos.Tests/Rpc/TestContextQueries.cs
@@ -228,6 +228,26 @@ public async Task TestContextContractStakedBalance()
             Assert.True(res is DJsonValue);
         }
 
+        [Fact]
+        public async Task TestContextContractSpendable()
+        {
+            var query = Rpc.Blocks.Head.Context.Contracts[TestContract].Spendable;
+            Assert.Equal($"chains/main/blocks/head/context/contracts/{TestContract}/spendable/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonValue);
+        }
+
+        [Fact]
+        public async Task TestContextContractSpendableAndFrozenBonds()
+        {
+            var query = Rpc.Blocks.Head.Context.Contracts[TestContract].SpendableAndFrozenBonds;
+            Assert.Equal($"chains/main/blocks/head/context/contracts/{TestContract}/spendable_and_frozen_bonds/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonValue);
+        }
+
         [Fact]
         public async Task TestContextContractStorage()
         {
@@ -383,73 +403,73 @@ public async Task TestContextDelegateActiveStakingParameters()
         }
 
         [Fact]
-        public async Task TestContextDelegateConsensusKey()
+        public async Task TestContextDelegateBakingPower()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].ConsensusKey;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/consensus_key/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].BakingPower;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/baking_power/", query.ToString());
 
             var res = await query.GetAsync();
-            Assert.True(res is DJsonObject);
+            Assert.True(res is DJsonValue);
         }
 
         [Fact]
-        public async Task TestContextDelegateCurrentBakingPower()
+        public async Task TestContextDelegateDelegators()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].CurrentBakingPower;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/current_baking_power/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].Delegators;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/delegators/", query.ToString());
 
             var res = await query.GetAsync();
-            Assert.True(res is DJsonValue);
+            Assert.True(res is DJsonArray);
         }
 
         [Fact]
-        public async Task TestContextDelegateCurrentFrozenDeposits()
+        public async Task TestContextDelegateExternalDelegated()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].CurrentFrozenDeposits;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/current_frozen_deposits/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].ExternalDelegated;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/external_delegated/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonValue);
         }
 
         [Fact]
-        public async Task TestContextDelegateCurrentVotingPower()
+        public async Task TestContextDelegateExternalStaked()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].CurrentVotingPower;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/current_voting_power/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].ExternalStaked;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/external_staked/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonValue);
         }
 
         [Fact]
-        public async Task TestContextDelegateDeactivated()
+        public async Task TestContextDelegateConsensusKey()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].Deactivated;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/deactivated/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].ConsensusKey;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/consensus_key/", query.ToString());
 
             var res = await query.GetAsync();
-            Assert.True(res is DJsonValue);
+            Assert.True(res is DJsonObject);
         }
 
         [Fact]
-        public async Task TestContextDelegateDelegatedBalance()
+        public async Task TestContextDelegateCurrentVotingPower()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].DelegatedBalance;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/delegated_balance/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].CurrentVotingPower;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/current_voting_power/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonValue);
         }
 
         [Fact]
-        public async Task TestContextDelegateDelegatedContracts()
+        public async Task TestContextDelegateDeactivated()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].DelegatedContracts;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/delegated_contracts/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].Deactivated;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/deactivated/", query.ToString());
 
             var res = await query.GetAsync();
-            Assert.True(res is DJsonArray);
+            Assert.True(res is DJsonValue);
         }
 
         [Fact]
@@ -473,6 +493,16 @@ public async Task TestContextDelegateEstimatedSharedPendingSlashedAmount()
             Assert.True(res is DJsonValue);
         }
 
+        [Fact]
+        public async Task TestContextDelegateGracePeriod()
+        {
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].GracePeriod;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/grace_period/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonValue);
+        }
+
         [Fact]
         public async Task TestContextDelegateIsForbidden()
         {
@@ -495,30 +525,30 @@ public async Task TestContextDelegateMinDelegatedInCurrentCycle()
         }
 
         [Fact]
-        public async Task TestContextDelegateFrozenDeposits()
+        public async Task TestContextDelegateOwnDelegated()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].FrozenDeposits;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/frozen_deposits/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].OwnDelegated;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/own_delegated/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonValue);
         }
-        
+
         [Fact]
-        public async Task TestContextDelegateFullBalance()
+        public async Task TestContextDelegateOwnFullBalance()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].FullBalance;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/full_balance/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].OwnFullBalance;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/own_full_balance/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonValue);
         }
 
         [Fact]
-        public async Task TestContextDelegateGracePeriod()
+        public async Task TestContextDelegateOwnStaked()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].GracePeriod;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/grace_period/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].OwnStaked;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/own_staked/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonValue);
@@ -555,10 +585,30 @@ public async Task TestContextDelegateStakingBalance()
         }
 
         [Fact]
-        public async Task TestContextDelegateUnstakedFrozenDeposits()
+        public async Task TestContextDelegateTotalDelegated()
+        {
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].TotalDelegated;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/total_delegated/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonValue);
+        }
+
+        [Fact]
+        public async Task TestContextDelegateTotalStaked()
         {
-            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].UnstakedFrozenDeposits;
-            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/unstaked_frozen_deposits/", query.ToString());
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].TotalStaked;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/total_staked/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonValue);
+        }
+
+        [Fact]
+        public async Task TestContextDelegateTotalUnstakedPerCycle()
+        {
+            var query = Rpc.Blocks.Head.Context.Delegates[TestDelegate].TotalUnstakedPerCycle;
+            Assert.Equal($"chains/main/blocks/head/context/delegates/{TestDelegate}/total_unstaked_per_cycle/", query.ToString());
 
             var res = await query.GetAsync();
             Assert.True(res is DJsonArray);
@@ -594,6 +644,16 @@ public async Task TestContextIssuanceCurrentYearlyRate()
             Assert.True(res is DJsonValue);
         }
 
+        [Fact]
+        public async Task TestContextIssuanceCurrentYearlyRateDetails()
+        {
+            var query = Rpc.Blocks.Head.Context.Issuance.CurrentYearlyRateDetails;
+            Assert.Equal($"chains/main/blocks/head/context/issuance/current_yearly_rate_details/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonObject);
+        }
+
         [Fact]
         public async Task TestContextIssuanceCurrentYearlyRateExact()
         {
@@ -697,6 +757,16 @@ public async Task TestContextSmartRollupStakers()
             Assert.True(res is DJsonArray);
         }
 
+        [Fact]
+        public async Task TestContextTotalCurrentlyStaked()
+        {
+            var query = Rpc.Blocks.Head.Context.TotalCurrentlyStaked;
+            Assert.Equal($"chains/main/blocks/head/context/total_currently_staked/", query.ToString());
+
+            var res = await query.GetAsync();
+            Assert.True(res is DJsonObject);
+        }
+
         [Fact]
         public async Task TestContextTotalFrozenStake()
         {
diff --git a/Netezos.Tests/Rpc/settings_ithaca.json b/Netezos.Tests/Rpc/settings_ghostnet.json
similarity index 87%
rename from Netezos.Tests/Rpc/settings_ithaca.json
rename to Netezos.Tests/Rpc/settings_ghostnet.json
index 800c7ed8..4ca84323 100644
--- a/Netezos.Tests/Rpc/settings_ithaca.json
+++ b/Netezos.Tests/Rpc/settings_ghostnet.json
@@ -1,5 +1,5 @@
 {
-  "node": "https://rpc.tzkt.io/ithacanet/",
+  "node": "https://rpc.tzkt.io/ghostnet/",
   "testContract": "KT1TxqZ8QtKvLu3V3JH7Gx58n7Co8pgtpQU5",
   "testEntrypoint": "default",
   "testDelegate": "tz1aWXP237BLwNHJcCD4b3DutCevhqq2T1Z9",
diff --git a/Netezos/Rpc/Queries/ContextQuery.cs b/Netezos/Rpc/Queries/ContextQuery.cs
index 6656f189..c8df056e 100644
--- a/Netezos/Rpc/Queries/ContextQuery.cs
+++ b/Netezos/Rpc/Queries/ContextQuery.cs
@@ -63,6 +63,11 @@ public class ContextQuery : RpcQuery
         /// </summary>
         public SmartRollupsQuery SmartRollups => new(this, "smart_rollups/");
         
+        /// <summary>
+        /// Returns the amount of staked tez by delegates, delegators or overstaked.
+        /// </summary>
+        public RpcObject TotalCurrentlyStaked => new(this, "total_currently_staked/");
+        
         /// <summary>
         /// Returns the total stake (in mutez) frozen on the chain.
         /// </summary>
diff --git a/Netezos/Rpc/Queries/ContractQuery.cs b/Netezos/Rpc/Queries/ContractQuery.cs
index c454907f..6e196faa 100644
--- a/Netezos/Rpc/Queries/ContractQuery.cs
+++ b/Netezos/Rpc/Queries/ContractQuery.cs
@@ -13,12 +13,16 @@ public class ContractQuery : RpcObject
         public RpcObject AllTicketBalances => new(this, "all_ticket_balances/");
         
         /// <summary>
-        /// Gets the query to the balance of a contract
+        /// Gets the query to the spendable balance of a contract (in mutez), also known as liquid balance. Corresponds
+        /// to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds.
+        /// Identical to the 'spendable' RPC.
         /// </summary>
         public RpcObject Balance => new(this, "balance/");
         
         /// <summary>
-        /// Gets the query to the sum of the spendable balance and frozen bonds of a contract.
+        /// Gets the query to the sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds
+        /// to the contract's full balance from which staked funds and unstake requests have been excluded. Identical
+        /// to the 'spendable_and_frozen_bonds' RPC.
         /// </summary>
         public RpcObject BalanceAndFrozenBonds => new(this, "balance_and_frozen_bonds/");
 
@@ -60,7 +64,9 @@ public class ContractQuery : RpcObject
         public RpcObject FrozenBonds => new(this, "frozen_bonds/");
 
         /// <summary>
-        /// Gets the query to the full balance of a contract, including frozen bonds and stake.
+        /// Gets the query to the full balance (in mutez) of the contract. Includes its spendable balance, staked tez,
+        /// unstake requests, and frozen bonds. Even if the contract is a delegate, it does not include any staked or
+        /// delegated tez owned by external delegators.
         /// </summary>
         public RpcObject FullBalance => new(this, "full_balance/");
 
@@ -81,15 +87,24 @@ public class ContractQuery : RpcObject
         public ScriptQuery Script => new(this, "script/");
 
         /// <summary>
-        /// Gets the query to the staked balance of a contract. Returns None if the contract is originated, or neither delegated nor a delegate.
+        /// Gets the query to the staked balance of a contract (in mutez). Returns None if the contract is originated,
+        /// or neither delegated nor a delegate.
         /// </summary>
         public RpcObject StakedBalance => new(this, "staked_balance/");
 
         /// <summary>
-        /// Gets the query to the flag, indicating if the contract tokens can be spent by the manager
+        /// Gets the query to the spendable balance of a contract (in mutez), also known as liquid balance. Corresponds
+        /// to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds.
+        /// Identical to the 'balance' RPC.
         /// </summary>
-        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject Spendable => new(this, "spendable/");
+        
+        /// <summary>
+        /// Gets the query to the sum (in mutez) of the spendable balance and frozen bonds of a contract. Corresponds
+        /// to the contract's full balance from which staked funds and unstake requests have been excluded. Identical
+        /// to the 'balance_and_frozen_bonds' RPC.
+        /// </summary>
+        public RpcObject SpendableAndFrozenBonds => new(this, "spendable_and_frozen_bonds/");
 
         /// <summary>
         /// Gets the query to the data of the contract's storage
diff --git a/Netezos/Rpc/Queries/DelegateQuery.cs b/Netezos/Rpc/Queries/DelegateQuery.cs
index 2ed4340e..a6821ec3 100644
--- a/Netezos/Rpc/Queries/DelegateQuery.cs
+++ b/Netezos/Rpc/Queries/DelegateQuery.cs
@@ -9,34 +9,43 @@ public class DelegateQuery : RpcObject
         /// Returns the currently active staking parameters for the given delegate.
         /// </summary>
         public RpcObject ActiveStakingParameters => new(this, "active_staking_parameters/");
-        
+
+        /// <summary>
+        /// Returns the current baking power of a delegate, using the current staked and delegated balances of the baker
+        /// and its delegators. In other words, the baking rights that the baker would get for a future cycle if the
+        /// current cycle ended right at the current block.
+        /// </summary>
+        public RpcObject BakingPower => new(this, "baking_power/");
+
         /// <summary>
         /// Gets the query to the full balance of a given delegate, including the frozen balances
         /// </summary>
         [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject Balance => new(this, "balance/");
-        
+
         /// <summary>
         /// The active consensus key for a given delegate and the pending consensus keys.
         /// </summary>
         public RpcObject ConsensusKey => new(this, "consensus_key/");
-        
+
         /// <summary>
         /// The baking power of a delegate, as computed from its current stake. This value is not used for computing baking
         /// rights but only reflects the baking power that the delegate would have if the cycle ended at the current block. 
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject CurrentBakingPower => new(this, "current_baking_power/");
-        
+
         /// <summary>
         /// Returns the current amount of the frozen deposits (in mutez).
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject CurrentFrozenDeposits => new(this, "current_frozen_deposits/");
-        
+
         /// <summary>
         /// The voting power of a given delegate, as computed from its current stake.
         /// </summary>
         public RpcObject CurrentVotingPower => new(this, "current_voting_power/");
-        
+
         /// <summary>
         /// Gets the query to the flag, indicating whether the delegate is currently tagged as deactivated or not
         /// </summary>
@@ -45,12 +54,20 @@ public class DelegateQuery : RpcObject
         /// <summary>
         /// Gets the query to the balances of all the contracts that delegate to a given delegate. This excludes the delegate's own balance and its frozen balances
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject DelegatedBalance => new(this, "delegated_balance/");
 
         /// <summary>
         /// Gets the query to the list of contracts that delegate to a given delegate
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject DelegatedContracts => new(this, "delegated_contracts/");
+        
+        /// <summary>
+        /// Gets the query to the list of all contracts that are currently delegating to the delegate. Includes both
+        /// user accounts and smart contracts. Includes the delegate itself.
+        /// </summary>
+        public RpcObject Delegators => new(this, "delegators/");
 
         /// <summary>
         /// Gets the query to the pending denunciations for the given delegate.
@@ -61,6 +78,23 @@ public class DelegateQuery : RpcObject
         /// Gets the query to the estimated shared pending slashed amount (in mutez) of a given delegate.
         /// </summary>
         public RpcObject EstimatedSharedPendingSlashedAmount => new(this, "estimated_shared_pending_slashed_amount/");
+        
+        /// <summary>
+        /// Gets the query to the sum (in mutez) of non-staked tokens that currently count as delegated to the baker,
+        /// excluding those owned by the baker iself. Does not take limits such as overstaking or overdelegation into
+        /// account. This includes the spendable balances and frozen bonds of all the baker's external delegators. It
+        /// also includes unstake requests of contracts other than the baker, on the condition that the contract was
+        /// delegating to the baker at the time of the unstake operation. So this includes most but not all unstake
+        /// requests from current delegators, and might include some unstake requests from old delegators. Limits such
+        /// as overstaking and overdelegation have not been applied yet.
+        /// </summary>
+        public RpcObject ExternalDelegated => new(this, "external_delegated/");
+        
+        /// <summary>
+        /// Gets the query to the sum (in mutez) of all tokens currently staked by the baker's external delegators. This
+        /// excludes the baker's own staked tokens.
+        /// </summary>
+        public RpcObject ExternalStaked => new(this, "external_staked/");
 
         /// <summary>
         /// Gets the query to the total frozen balances of a given delegate, this includes the frozen deposits, rewards and fees
@@ -75,8 +109,10 @@ public class DelegateQuery : RpcObject
         public RpcObject FrozenBalanceByCycle => new(this, "frozen_balance_by_cycle/");
 
         /// <summary>
-        /// Returns the initial amount (that is, at the beginning of a cycle) of the frozen deposits (in mutez). This amount is the same as the current amount of the frozen deposits, unless the delegate has been punished.
+        /// Returns the initial amount (that is, at the beginning of a cycle) of the frozen deposits (in mutez). This
+        /// amount is the same as the current amount of the frozen deposits, unless the delegate has been punished.
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject FrozenDeposits => new(this, "frozen_deposits/");
 
         /// <summary>
@@ -88,8 +124,9 @@ public class DelegateQuery : RpcObject
         /// <summary>
         /// Gets the query to the full balance of a given delegate, including the frozen balances
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject FullBalance => new(this, "full_balance/");
-        
+
         /// <summary>
         /// Gets the query to the cycle by the end of which the delegate might be deactivated if he fails to execute any delegate action
         /// </summary>
@@ -105,6 +142,31 @@ public class DelegateQuery : RpcObject
         /// this value was last updated. 
         /// </summary>
         public RpcObject MinDelegatedInCurrentCycle => new(this, "min_delegated_in_current_cycle/");
+        
+        /// <summary>
+        /// Gets the query to the amount (in mutez) currently owned by the baker itself and counting as delegated for
+        /// the purpose of baking rights. This corresponds to all non-staked tokens owned by the baker: spendable
+        /// balance, frozen bonds, and unstake requests. (Note: There is one exception: if the baker still has unstake
+        /// requests created at a time when it was delegating to a different delegate, then these unstake requests still
+        /// count as delegated to the former delegate. Any such unstake requests are excluded from the amount returned
+        /// by the present RPC, despite being non-staked tokens owned by the baker.)
+        /// </summary>
+        public RpcObject OwnDelegated => new(this, "own_delegated/");
+        
+        /// <summary>
+        /// Gets the query to the full balance (in mutez) of tokens owned by the delegate itself. Includes its spendable
+        /// balance, staked tez, unstake requests, and frozen bonds. Does not include any tokens owned by external
+        /// delegators. This RPC fails when the pkh is not a delegate. When it is a delegate, this RPC outputs the same
+        /// amount as ../:block_id/context/contracts/:delegate_contract_id/full_balance.
+        /// </summary>
+        public RpcObject OwnFullBalance => new(this, "own_full_balance/");
+        
+        /// <summary>
+        /// Gets the query to the amount (in mutez) currently owned and staked by the baker itself. Returns the same
+        /// value as ../:block_id/context/contracts/:delegate_contract_id/staked_balance (except for the fact that the
+        /// present RPC fails if the public_key_hash in the path is not a delegate).
+        /// </summary>
+        public RpcObject OwnStaked => new(this, "own_staked/");
 
         /// <summary>
         /// Returns cycle and level participation information. In particular this indicates, in the field 'expected_cycle_activity',
@@ -124,22 +186,50 @@ public class DelegateQuery : RpcObject
         /// Gets the query to the total amount of tokens delegated to a given delegate, including the balance of the delegate itself and its frozen fees and deposits
         /// </summary>
         public RpcObject StakingBalance => new(this, "staking_balance/");
+        
+        /// <summary>
+        /// Gets the query to the all tokens (in mutez) that currently count as delegated for the purpose of computing
+        /// the baker's rights; they weigh half as much as staked tez in the rights. Limits such as overstaking and
+        /// overdelegation have not been applied yet. This corresponds to all non-staked tez owned by the baker's
+        /// delegators (including the baker itself): spendable balances, frozen bonds, and unstaked requests, except for
+        /// any unstake requests that have been created before the delegator changed its delegate to the current baker
+        /// (because they still count as delegated for the old delegate instead).
+        /// </summary>
+        public RpcObject TotalDelegated => new(this, "total_delegated/");
+        
+        /// <summary>
+        /// Gets the query to the total amount (in mutez) currently staked for the baker, both by the baker itself and
+        /// by external stakers. This is the staked amount before applying the baker's 'limit_of_staking_over_baking';
+        /// in other words, it includes overstaked tez if there are any.
+        /// </summary>
+        public RpcObject TotalStaked => new(this, "total_staked/");
+        
+        /// <summary>
+        /// Gets the query that returns for each cycle the total amount (in mutez) contained in all unstake requests
+        /// created during this cycle by all delegators, including the baker itself. Note that these tokens count as
+        /// delegated to the baker for the purpose of computing baking rights, and are included in the amount returned
+        /// by the total_delegated RPC.
+        /// </summary>
+        public RpcObject TotalUnstakedPerCycle => new(this, "total_unstaked_per_cycle/");
 
         /// <summary>
         /// Returns, for each cycle, the sum of unstaked-but-frozen deposits for this cycle. Cycles go from the last unslashable cycle to the current cycle.
         /// </summary>
+        [Obsolete("This RPC query was removed. Use it on early protocols only.")]
         public RpcObject UnstakedFrozenDeposits => new(this, "unstaked_frozen_deposits/");
 
         /// <summary>
         /// The number of rolls in the vote listings for a given delegate
         /// </summary>
         public RpcObject VotingInfo => new(this, "voting_info/");
-        
+
         /// <summary>
         /// The number of rolls in the vote listings for a given delegate
         /// </summary>
         public RpcObject VotingPower => new(this, "voting_power/");
 
-        internal DelegateQuery(RpcQuery baseQuery, string append) : base(baseQuery, append) { }
+        internal DelegateQuery(RpcQuery baseQuery, string append) : base(baseQuery, append)
+        {
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/Netezos/Rpc/Queries/IssuanceQuery.cs b/Netezos/Rpc/Queries/IssuanceQuery.cs
index 68a02c1c..a1dee448 100644
--- a/Netezos/Rpc/Queries/IssuanceQuery.cs
+++ b/Netezos/Rpc/Queries/IssuanceQuery.cs
@@ -6,22 +6,31 @@
 public class IssuanceQuery : RpcQuery
 {
     /// <summary>
-    /// Returns the current expected maximum yearly issuance rate (in %).
+    /// Returns the current expected maximum yearly issuance rate (in %). The value only includes participation rewards
+    /// (and does not include liquidity baking)
     /// </summary>
     public RpcObject CurrentYearlyRate => new(this, "current_yearly_rate/");
+    
+    /// <summary>
+    /// Returns the static and dynamic parts of the current expected maximum yearly issuance rate (in %). The value only
+    /// includes participation rewards (and does not include liquidity baking)
+    /// </summary>
+    public RpcObject CurrentYearlyRateDetails => new(this, "current_yearly_rate_details/");
         
     /// <summary>
-    /// Returns the current expected maximum yearly issuance rate (exact quotient).
+    /// Returns the current expected maximum yearly issuance rate (exact quotient) (in %). The value only includes
+    /// participation rewards (and does not include liquidity baking)
     /// </summary>
     public RpcObject CurrentYearlyRateExact => new(this, "current_yearly_rate_exact/");
         
     /// <summary>
-    /// Returns the expected issued tez for the provided block and the next 'consensus_rights_delay' cycles.
+    /// Returns the expected issued tez for the provided block and the next 'consensus_rights_delay' cycles (in mutez)
     /// </summary>
     public RpcObject ExpectedIssuance => new(this, "expected_issuance/");
         
     /// <summary>
-    /// Returns the current expected maximum issuance per minute (in mutez).
+    /// Returns the current expected maximum issuance per minute (in mutez). The value only includes participation
+    /// rewards (and does not include liquidity baking)
     /// </summary>
     public RpcObject IssuancePerMinute => new(this, "issuance_per_minute/");